diff --git a/src/main/environment/common_ci.properties b/src/main/environment/common_ci.properties index abf01fd6..84c70090 100644 --- a/src/main/environment/common_ci.properties +++ b/src/main/environment/common_ci.properties @@ -160,6 +160,6 @@ grievanceDataSyncDuration = @env.GRIEVANCE_DATA_SYNC_DURATION@ springdoc.api-docs.enabled=false springdoc.swagger-ui.enabled=false -grievanceAllocationRetryConfiguration=1 +grievanceAllocationRetryConfiguration=3 diff --git a/src/main/environment/common_dev.properties b/src/main/environment/common_dev.properties index ee25f9c9..d59acb42 100644 --- a/src/main/environment/common_dev.properties +++ b/src/main/environment/common_dev.properties @@ -186,4 +186,4 @@ grievanceDataSyncDuration = springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true -grievanceAllocationRetryConfiguration=1 +grievanceAllocationRetryConfiguration=3 diff --git a/src/main/environment/common_example.properties b/src/main/environment/common_example.properties index 1c752ac1..bcc6c6ca 100644 --- a/src/main/environment/common_example.properties +++ b/src/main/environment/common_example.properties @@ -186,7 +186,7 @@ grievanceDataSyncDuration = springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true -grievanceAllocationRetryConfiguration=1 +grievanceAllocationRetryConfiguration=3 diff --git a/src/main/environment/common_test.properties b/src/main/environment/common_test.properties index fd3de195..169317db 100644 --- a/src/main/environment/common_test.properties +++ b/src/main/environment/common_test.properties @@ -188,4 +188,4 @@ grievanceDataSyncDuration = springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true -grievanceAllocationRetryConfiguration=1 +grievanceAllocationRetryConfiguration=3 diff --git a/src/main/environment/common_uat.properties b/src/main/environment/common_uat.properties index d0914520..0b55a003 100644 --- a/src/main/environment/common_uat.properties +++ b/src/main/environment/common_uat.properties @@ -159,4 +159,4 @@ grievanceDataSyncDuration = springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true -grievanceAllocationRetryConfiguration=1 +grievanceAllocationRetryConfiguration=3 diff --git a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java index dcfea8f7..a4e3212c 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -48,7 +48,7 @@ public GrievanceController(GrievanceHandlingService grievanceHandlingService, Gr public String fetchUnallocatedGrievanceCount(@RequestBody UnallocationRequest request) { OutputResponse responseData = new OutputResponse(); try { - responseData.setResponse(grievanceDataSync.fetchUnallocatedGrievanceCount(request.getPreferredLanguageName())); + responseData.setResponse(grievanceDataSync.fetchUnallocatedGrievanceCount(request.getPreferredLanguageName(), request.getFilterStartDate(), request.getFilterEndDate(), request.getProviderServiceMapID())); } catch (IEMRException e) { logger.error("Business logic error in UnallocatedGrievanceCount" + e.getMessage(), e); responseData.setError(e); @@ -87,7 +87,7 @@ public String allocateGrievances( @Operation(summary = "Allocated Grievance Records Count") @PostMapping(value = "/allocatedGrievanceRecordsCount", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") public String allocatedGrievanceRecordsCount(@Param(value = "{\"providerServiceMapID\":\"Service ID integer\", " - + "\"assignedUserID\":\"Optional - Integer user ID to whom grievances are assigned\"}") @RequestBody String request) { + + "\"userID\":\"Optional - Integer user ID to whom grievances are assigned\"}") @RequestBody String request) { OutputResponse response = new OutputResponse(); try { response.setResponse(grievanceHandlingService.allocatedGrievanceRecordsCount(request)); @@ -130,13 +130,19 @@ public String moveToBin(@RequestBody String request) { @Operation(summary = "get grievance outbound worklist)") @PostMapping(value = "/getGrievanceOutboundWorklist", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") - public ResponseEntity> getGrievanceOutboundWorklist(@Param(value = "{\"providerServiceMapId\":\" called service ID integer\", " + public ResponseEntity> getGrievanceOutboundWorklist(@Param(value = "{\"providerServiceMapId\":\" called service ID integer\", " + "\"userId\":\"Optional - Integer ID of user that is assigned to\"}") @RequestBody String request) { logger.info("Request received for grievance worklist"); List response = new ArrayList<>(); + Map responseMap = new HashMap<>(); + try { response = grievanceHandlingService.getFormattedGrievanceData(request); - + // Prepare the success response structure + responseMap.put("data", response); + responseMap.put("statusCode", HttpStatus.OK.value()); + responseMap.put("errorMessage", "Success"); + responseMap.put("status", "Success"); } catch (Exception e) { @@ -148,12 +154,81 @@ public ResponseEntity> getGrievanceOutboundWorklist(@ // Return error response with empty list and error message errorResponse.add(errorDTO); - return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse); + + responseMap.put("data", errorResponse); + responseMap.put("statusCode", HttpStatus.INTERNAL_SERVER_ERROR.value()); + responseMap.put("errorMessage", e.getMessage()); + responseMap.put("status", "Error"); } - return ResponseEntity.ok(response); + return ResponseEntity.ok(responseMap); } + + @Operation(summary = "Save complaint resolution and remarks") + @PostMapping(value = "/saveComplaintResolution", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + public String saveComplaintResolution( @Param(value = "{\"complaintID\":\"Complaint ID string\", " + + "\"complaintResolution\":\"Resolution text\", " + + "\"remarks\":\"Optional remarks\", " + + "\"beneficiaryRegID\":\"Beneficiary registration ID\", " + + "\"providerServiceMapID\":\"Provider service map ID\", " + + "\"userID\":\"Assigned user ID\", " + + "\"createdBy\":\"Creator of the complaint\", " + + "\"benCallID\":\"Beneficiary call ID\"}") + @RequestBody String request) { + OutputResponse response = new OutputResponse(); + try { + response.setResponse(grievanceHandlingService.saveComplaintResolution(request)); + } catch (Exception e) { + logger.error("saveComplaintResolution failed with error " + e.getMessage(), e); + response.setError(e); + } + return response.toString(); + } + + + // Controller method to handle reattempt logic + @Operation(summary = "Check reattempt logic for grievance") + @PostMapping(value = "/completeGrievanceCall", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + public String completeGrievanceCall( + @Param(value = "{\"complaintID\":\"String - ComplaintID\", " + + "\"userID\":\"Integer - Assigned UserID\", " + + "\"isCompleted\":\"Boolean - completion status of call\", " + + "\"beneficiaryRegId\":\"Long - Beneficiary Registration ID\", " + + "\"callTypeID\":\"Integer - Call Type ID\", " + + "\"benCallID\":\"Long - Beneficiary Call ID\", " + +"\"callID\":\"String - call ID by czentrix\", " + + "\"providerServiceMapID\":\"Integer - providerServiceMapID\", " + + "\"createdBy\":\"String - Creator\"}") + @RequestBody String request) { + + OutputResponse response = new OutputResponse(); + + try { + String s = grievanceDataSync.completeGrievanceCall(request); + response.setResponse(s); + + } catch (Exception e) { + logger.error("complete grievance outbound call failed with error " + e.getMessage(), e); + response.setError(e); + } + return response.toString(); + } + + + @Operation(summary = "Get Grievance Details with Remarks") + @PostMapping(value = "/getCompleteGrievanceDetails", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + public String getGrievanceDetailsWithRemarks(@RequestBody String request) { + OutputResponse response = new OutputResponse(); + try { + response.setResponse(grievanceHandlingService.getGrievanceDetailsWithRemarks(request)); + } catch (Exception e) { + logger.error("getGrievanceDetailsWithRemarks failed with error " + e.getMessage(), e); + response.setError(e); + } + return response.toString(); + } + } diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceAllocationRequest.java b/src/main/java/com/iemr/common/data/grievance/GrievanceAllocationRequest.java index 8dc30cc1..3f182548 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceAllocationRequest.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceAllocationRequest.java @@ -10,14 +10,14 @@ public class GrievanceAllocationRequest { private Timestamp startDate; // Start date for filtering grievances private Timestamp endDate; // End date for filtering grievances - private List userID; // List of user IDs (agents) to whom grievances will be allocated + private List touserID; // List of user IDs (agents) to whom grievances will be allocated private Integer allocateNo; // Number of grievances to be allocated to each user - private String preferredLanguage; + private String language; @Override public String toString() { - return "GrievanceAllocationRequest{" + "startDate=" + startDate + ", endDate=" + endDate + ", userID=" + userID - + ", allocateNo=" + allocateNo + ", language=" + preferredLanguage + '}'; + return "GrievanceAllocationRequest{" + "startDate=" + startDate + ", endDate=" + endDate + ", touserID=" + touserID + + ", allocateNo=" + allocateNo + ", language=" + language + '}'; } } diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java b/src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java new file mode 100644 index 00000000..17178003 --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java @@ -0,0 +1,17 @@ +package com.iemr.common.data.grievance; + +import lombok.Data; + +@Data +public class GrievanceCallRequest { + + String complaintID; + Integer userID; + Boolean isCompleted; + Long beneficiaryRegID; + Integer callTypeID; + Long benCallID; + Integer providerServiceMapID; + String createdBy; + +} diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java index 1a39edf1..17019b54 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -16,6 +16,7 @@ import jakarta.persistence.OneToMany; import jakarta.persistence.Table; import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; import lombok.Data; import lombok.NoArgsConstructor; @@ -70,18 +71,14 @@ public class GrievanceDetails { @Expose @Column(name = "Level") - private String level; + private Integer level; @Expose @Column(name = "State") private String state; - @Expose - @Column(name = "Agentid") - private String agentid; - @Expose @Column(name = "userid") - private Integer assignedUserID; + private Integer userID; @Expose @Column(name = "isAllocated") @@ -106,6 +103,15 @@ public class GrievanceDetails { @Expose @Column(name = "PreferredLanguage") private String preferredLanguage; + + @Expose + @Column(name = "ComplaintResolution") + private String complaintResolution; + + @Expose + @Column(name = "Remarks") + @Size(max = 5000, message = "Remarks cannot exceed 5000 characters") + private String remarks; @Column(name = "Deleted", insertable = false, updatable = true) private Boolean deleted = false; @@ -130,7 +136,7 @@ public class GrievanceDetails { @Expose @Column(name = "VanSerialNo") - private Integer vanSerialNo; + private Long vanSerialNo; @Expose @Column(name = "VanID") private Integer vanID; @@ -159,10 +165,10 @@ public class GrievanceDetails { public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long benCallID, Integer providerServiceMapID, String complaintID, String subjectOfComplaint, String complaint, - String primaryNumber, String severety, String state, String agentID, Integer userid, Boolean isAllocated, + String primaryNumber, String severety, Integer level, String state, Integer userid, Boolean isAllocated, Boolean retryNeeded, Boolean isRegistered, Integer callCounter, Integer preferredLanguageId, - String preferredLanguage, Boolean deleted, Character processed, String createdBy, Timestamp createdDate, - String modifiedBy, Timestamp lastModDate, Integer vanSerialNo, Integer vanID, String vehicalNo, + String preferredLanguage, String complaintResolution, String remarks, Boolean deleted, Character processed, String createdBy, Timestamp createdDate, + String modifiedBy, Timestamp lastModDate, Long vanSerialNo, Integer vanID, String vehicalNo, Integer parkingPlaceID, String syncedBy, Timestamp syncedDate, Boolean isCompleted) { super(); this.gwid = gwid; @@ -175,15 +181,17 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long this.complaint = complaint; this.primaryNumber = primaryNumber; this.severety = severety; + this.level = level; this.state = state; - this.agentid = agentID; - this.assignedUserID = userid; + this.userID = userid; this.isAllocated = isAllocated; this.retryNeeded = retryNeeded; this.isRegistered = isRegistered; this.callCounter = callCounter; this.preferredLanguageId = preferredLanguageId; this.preferredLanguage = preferredLanguage; + this.complaintResolution = complaintResolution; + this.remarks = remarks; this.deleted = deleted; this.processed = processed; this.createdBy = createdBy; diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceResponse.java b/src/main/java/com/iemr/common/data/grievance/GrievanceResponse.java new file mode 100644 index 00000000..516df3dd --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceResponse.java @@ -0,0 +1,70 @@ +package com.iemr.common.data.grievance; + +import java.sql.Timestamp; + +public class GrievanceResponse { + private Long grievanceId; + private String complaintID; + private String primaryNumber; + private String complaintResolution; + private String remarks; + private Timestamp createdDate; + private Timestamp lastModDate; + + // Getters and Setters + public Long getGrievanceId() { + return grievanceId; + } + + public void setGrievanceId(Long grievanceId) { + this.grievanceId = grievanceId; + } + + public String getComplaintID() { + return complaintID; + } + + public void setComplaintID(String complaintID) { + this.complaintID = complaintID; + } + + public String getPrimaryNumber() { + return primaryNumber; + } + + public void setPrimaryNumber(String primaryNumber) { + this.primaryNumber = primaryNumber; + } + + public String getComplaintResolution() { + return complaintResolution; + } + + public void setComplaintResolution(String complaintResolution) { + this.complaintResolution = complaintResolution; + } + + public String getRemarks() { + return remarks; + } + + public void setRemarks(String remarks) { + this.remarks = remarks; + } + + public Timestamp getCreatedDate() { + return createdDate; + } + + public void setCreatedDate(Timestamp createdDate) { + this.createdDate = createdDate; + } + + public Timestamp getLastModDate() { + return lastModDate; + } + + public void setLastModDate(Timestamp lastModDate) { + this.lastModDate = lastModDate; + } +} diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java index 7d162461..628c9ca8 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java @@ -24,16 +24,19 @@ public class GrievanceTransaction { @Column(name = "gwid", nullable = false) @Expose private Long gwid; + + @Column(name = "GrievanceId") + @Expose + private Long grievanceId; + @Column(name = "FileName", nullable = false, length = 500) @Expose - @NotBlank(message = "File name is required") @Size(max = 500, message = "File name cannot exceed 500 characters") private String fileName; @Column(name = "FileType", nullable = false, length = 300) @Expose - @NotBlank(message = "File name is required") @Size(max = 300, message = "File type cannot exceed 300 characters") private String fileType; @@ -73,10 +76,6 @@ public class GrievanceTransaction { @Expose private String status; - @Column(name = "Comment") - @Expose - private String comment; - @Column(name = "CreatedBy", nullable = false) @Expose private String createdBy; @@ -113,6 +112,15 @@ public Long getGwid() { public void setGwid(Long gwid) { this.gwid = gwid; } + + public Long getGrievanceId() { + return grievanceId; + } + + public void setGrievanceId(Long grievanceId) { + this.grievanceId = grievanceId; + } + public String getFileName() { return fileName; @@ -234,12 +242,6 @@ public void setStatus(String status) { this.status = status; } - public String getComment( ) { - return comment; - } - - public void setComment(String comment ) { - this.comment = comment; - } + } diff --git a/src/main/java/com/iemr/common/data/grievance/MoveToBinRequest.java b/src/main/java/com/iemr/common/data/grievance/MoveToBinRequest.java index 7c095ec1..52c391b7 100644 --- a/src/main/java/com/iemr/common/data/grievance/MoveToBinRequest.java +++ b/src/main/java/com/iemr/common/data/grievance/MoveToBinRequest.java @@ -6,7 +6,7 @@ public class MoveToBinRequest { private Integer providerServiceMapID; - private Integer assignedUserID; + private Integer userID; private String preferredLanguageName; private Boolean is1097; private Integer noOfCalls; diff --git a/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java b/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java index 6243e001..48d25b7e 100644 --- a/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java +++ b/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java @@ -9,7 +9,9 @@ @Data public class GrievanceTransactionDTO implements Serializable { private static final long serialVersionUID = 1L; - + + private String actionTakenBy; + private String status; private String fileName; private String fileType; private String redressed; @@ -20,9 +22,12 @@ public class GrievanceTransactionDTO implements Serializable { // Constructor, Getters, and Setters public GrievanceTransactionDTO( + String actionTakenBy, String status, String fileName, String fileType, String redressed, Timestamp createdAt, Timestamp updatedAt, String comment) { super(); + this.actionTakenBy = actionTakenBy; + this.status = status; this.fileName = fileName; this.fileType = fileType; this.redressed = redressed; diff --git a/src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java b/src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java index 6e4b1604..365c76a3 100644 --- a/src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java +++ b/src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java @@ -37,15 +37,14 @@ public class GrievanceWorklistDTO implements Serializable { private String age; private Boolean retryNeeded; private Integer callCounter; - // private String lastCall; // Add this field if you want - + private Timestamp lastCall; public GrievanceWorklistDTO(String complaintID, String subjectOfComplaint, String complaint, Long beneficiaryRegID, Integer providerServiceMapID, String firstName, String lastName, String primaryNumber, List transactions, String severety, String state, Integer userId, Boolean deleted, String createdBy, Timestamp createdDate, Timestamp lastModDate, Boolean isCompleted, String gender, String district, Long beneficiaryID, String age, - Boolean retryNeeded, Integer callCounter) { + Boolean retryNeeded, Integer callCounter, Timestamp lastCall) { super(); this.complaintID = complaintID; this.subjectOfComplaint = subjectOfComplaint; @@ -70,6 +69,7 @@ public GrievanceWorklistDTO(String complaintID, String subjectOfComplaint, Strin this.age = age; this.retryNeeded = retryNeeded; this.callCounter = callCounter; + this.lastCall = lastCall; } diff --git a/src/main/java/com/iemr/common/repository/callhandling/BeneficiaryCallRepository.java b/src/main/java/com/iemr/common/repository/callhandling/BeneficiaryCallRepository.java index 60ec1b71..e48e8f9d 100644 --- a/src/main/java/com/iemr/common/repository/callhandling/BeneficiaryCallRepository.java +++ b/src/main/java/com/iemr/common/repository/callhandling/BeneficiaryCallRepository.java @@ -190,5 +190,8 @@ public ArrayList getExistingBCByCallIDAndAgentID(@Param("callID public int updateBeneficiaryRegIDInCall(@Param("benCallID") Long benCallID, @Param("beneficiaryRegID") Long beneficiaryRegID); BeneficiaryCall findByBenCallID(Long benCallID); + + @Query("SELECT b.remarks FROM BeneficiaryCall b WHERE b.beneficiaryRegID = :beneficiaryRegID") + List fetchBenCallRemarks(@Param("beneficiaryRegID") Long beneficiaryRegID); } diff --git a/src/main/java/com/iemr/common/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java b/src/main/java/com/iemr/common/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java index 8a5d3d29..0e98bf1d 100644 --- a/src/main/java/com/iemr/common/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java +++ b/src/main/java/com/iemr/common/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java @@ -88,5 +88,7 @@ Set getOutboundCallTypes(@Param("providerServiceMapID") Integer provid @Query("select callType from CallType callType where deleted = false and callTypeID = :callTypeID") CallType getCallTypeDetails(@Param("callTypeID") Integer callTypeID); - + @Query("select callGroupType, callType from CallType " + + "where callTypeID = :callTypeID") + Set getCallDetails(@Param("callTypeID") Integer callTypeID); } diff --git a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java index 151ab91d..7d8f39b7 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -2,6 +2,7 @@ import java.sql.Timestamp; import java.util.ArrayList; +import java.util.Date; import java.util.List; import java.util.Set; @@ -27,48 +28,138 @@ List findGrievancesInDateRangeAndLanguage(@Param("startDate") @Modifying - @Query("UPDATE GrievanceDetails g SET g.isAllocated = true, g.assignedUserID = :assignedUserId WHERE g.grievanceId = :grievanceId") + @Query("UPDATE GrievanceDetails g SET g.isAllocated = true, g.userID = :userId WHERE g.grievanceId = :grievanceId") @Transactional public int allocateGrievance(@Param("grievanceId") Long grievanceId, - @Param("assignedUserId") Integer assignedUserId); + @Param("userId") Integer userId); - @Query(nativeQuery = true, value = "SELECT PreferredLanguageId, PreferredLanguage, VanSerialNo, VanID, ParkingPlaceId, VehicalNo FROM db_identity.i_beneficiarydetails WHERE BeneficiaryRegID = :benRegId") + @Query(nativeQuery = true, value = "SELECT PreferredLanguageId, PreferredLanguage, VanSerialNo, VanID, ParkingPlaceId, VehicalNo FROM db_1097_identity.i_beneficiarydetails WHERE BeneficiaryRegID = :benRegId") public ArrayList getBeneficiaryGrievanceDetails(@Param("benRegId") Long benRegId); + @Query(nativeQuery = true, value = "SELECT t2.preferredPhoneNum FROM db_1097_identity.i_beneficiarymapping t1 join" + + " db_1097_identity.i_beneficiarycontacts t2 on t1.benContactsId = t2.benContactsID" + + " where benRegId = :benRegId") + public String getPrimaryNumber(@Param("benRegId") Long benRegId); + + @Query("select grievance.preferredLanguage, count(distinct grievance.grievanceId) " + "from GrievanceDetails grievance " + "where grievance.providerServiceMapID = :providerServiceMapID " - + "and grievance.assignedUserID = :assignedUserID " + "and grievance.deleted = false " + + "and grievance.userID = :userID " + "and grievance.deleted = false " + "group by grievance.preferredLanguage") public Set fetchGrievanceRecordsCount(@Param("providerServiceMapID") Integer providerServiceMapID, - @Param("assignedUserID") Integer assignedUserID); + @Param("userID") Integer userID); - @Query("SELECT g FROM GrievanceDetails g WHERE g.assignedUserID = :assignedUserID AND g.preferredLanguage = :language AND g.isAllocated = true") - List findAllocatedGrievancesByUserAndLanguage(@Param("assignedUserID") Integer assignedUserID, + @Query("SELECT g FROM GrievanceDetails g WHERE g.userID = :userID AND g.preferredLanguage = :language AND g.isAllocated = true") + List findAllocatedGrievancesByUserAndLanguage(@Param("userID") Integer userID, @Param("language") String language); @Modifying - @Query("UPDATE GrievanceDetails g SET g.assignedUserID = :assignedUserID WHERE g.grievanceId = :grievanceId") + @Query("UPDATE GrievanceDetails g SET g.userID = :userID WHERE g.grievanceId = :grievanceId") @Transactional public int reallocateGrievance(@Param("grievanceId") Long grievanceId, - @Param("assignedUserID") Integer assignedUserID); + @Param("userID") Integer userID); - @Query("SELECT g FROM GrievanceDetails g WHERE g.assignedUserID = :assignedUserID " + @Query("SELECT g FROM GrievanceDetails g WHERE g.userID = :userID " + "AND g.preferredLanguage = :preferredLanguageName") - List findGrievancesByUserAndLanguage(@Param("assignedUserID") Integer assignedUserID, + List findGrievancesByUserAndLanguage(@Param("userID") Integer userID, @Param("preferredLanguageName") String language); @Modifying @Transactional - @Query("UPDATE GrievanceDetails g SET g.assignedUserID = NULL WHERE g.grievanceId = :grievanceId AND g.assignedUserID = :assignedUserID") - int unassignGrievance(@Param("grievanceId") Long grievanceId, @Param("assignedUserID") Integer assignedUserID); + @Query("UPDATE GrievanceDetails g SET g.userID = :userID WHERE g.gwid = :gwid") + int unassignGrievance(@Param("userID") Integer userID, @Param("gwid") Long gwid); @Modifying @Transactional - @Query("UPDATE GrievanceDetails g SET g.isAllocated = :isAllocated WHERE g.grievanceId = :grievanceId") - int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, + @Query("UPDATE GrievanceDetails g SET g.isAllocated = :isAllocated WHERE g.gwid = :gwid") + int updateGrievanceAllocationStatus(@Param("gwid") Long gwid, @Param("isAllocated") Boolean isAllocated); - @Query("Select grievance.preferredLanguage, count(grievance) from GrievanceDetails grievance where grievance.isAllocated=false group by grievance.preferredLanguage") - public Set fetchUnallocatedGrievanceCount(); + @Query("Select grievance.preferredLanguage, count(grievance) from GrievanceDetails grievance where grievance.isAllocated=false " + + "AND grievance.createdDate BETWEEN :filterStartDate AND :filterEndDate " + + "group by grievance.preferredLanguage") + public Set fetchUnallocatedGrievanceCount( + @Param("filterStartDate") Timestamp filterStartDate, + @Param("filterEndDate") Timestamp filterEndDate); + + @Modifying + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy, " + + "g.benCallID = :benCallID " + + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + + " AND g.userID = :userID") + @Transactional + int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, + @Param("remarks") String remarks, + @Param("modifiedBy") String modifiedBy, + @Param("benCallID") Long benCallID, + @Param("complaintID") String complaintID, + @Param("beneficiaryRegID") Long beneficiaryRegID, + @Param("providerServiceMapID") Integer providerServiceMapID, + @Param("userID") Integer userID); + + @Modifying + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy, " + + "g.benCallID = :benCallID " + + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + + " AND g.userID = :userID") + @Transactional + int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, + @Param("modifiedBy") String modifiedBy, + @Param("benCallID") Long benCallID, + @Param("complaintID") String complaintID, + @Param("beneficiaryRegID") Long beneficiaryRegID, + @Param("providerServiceMapID") Integer providerServiceMapID, + @Param("userID") Integer userID); + + @Query(" Select grievance.callCounter, grievance.retryNeeded FROM GrievanceDetails grievance where grievance.complaintID = :complaintID") + public List getCallCounter(@Param("complaintID") String complaintID); + + @Modifying + @Query("UPDATE GrievanceDetails g SET g.isCompleted = :isCompleted, g.retryNeeded = :retryNeeded " + + "WHERE g.complaintID = :complaintID AND g.userID = :userID AND g.beneficiaryRegID = :beneficiaryRegID " + + "AND g.providerServiceMapID = :providerServiceMapID") + @Transactional + public int updateCompletedStatusInCall(@Param("isCompleted") Boolean isCompleted, + @Param("retryNeeded") Boolean retryNeeded, + @Param("complaintID") String complaintID, + @Param("userID") Integer userID, + @Param("beneficiaryRegID") Long beneficiaryRegID, + @Param("providerServiceMapID") Integer providerServiceMapID); + + + @Modifying + @Query("UPDATE GrievanceDetails g SET g.callCounter = :callCounter, g.retryNeeded = :retryNeeded " + + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + + " AND g.userID = :userID") + @Transactional + public int updateCallCounter(@Param("callCounter") Integer callCounter, + @Param("retryNeeded") Boolean retryNeeded, + @Param("complaintID") String complaintID, + @Param("beneficiaryRegID") Long beneficiaryRegID, + @Param("providerServiceMapID") Integer providerServiceMapID, + @Param("userID") Integer userID); + + @Query("SELECT g FROM GrievanceDetails g WHERE " + + "(g.state = :state OR :state IS NULL) " + + "AND (g.complaintResolution = :complaintResolution OR :complaintResolution IS NULL) " + + "AND g.createdDate BETWEEN :startDate AND :endDate") + List fetchGrievanceDetailsBasedOnParams( + @Param("state") String state, + @Param("complaintResolution") String complaintResolution, + @Param("startDate") Date startDate, + @Param("endDate") Date endDate); + + + @Query("SELECT g FROM GrievanceDetails g WHERE g.complaintID = :complaintID") + List fetchGrievanceWorklistByComplaintID(@Param("complaintID") String complaintID); + + +@Query("SELECT g.remarks FROM GrievanceDetails g WHERE g.complaintID = :complaintID") +List fetchGrievanceWorklistRemarks(@Param("complaintID") String complaintID); + +@Query("SELECT g.gwid FROM GrievanceDetails g WHERE g.grievanceId = :grievanceId") +Long getUniqueGwid(@Param("grievanceId")Long grievanceIdObj); + + } diff --git a/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java index 326b80c8..da485511 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java @@ -14,7 +14,7 @@ @Repository public interface GrievanceFetchBenDetailsRepo extends CrudRepository { - @Query("select f.requestID, f.benCallID, f.beneficiaryRegID, f.serviceID, f.stateID " + @Query("select f.requestID, f.benCallID, f.beneficiaryRegID, f.serviceID" + " from FeedbackDetails f where f.requestID = :requestID order by f.requestID desc") public ArrayList findByComplaintId(@Param("requestID") String requestID); diff --git a/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java index 88c50d66..88c8dfa9 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java @@ -3,21 +3,20 @@ import java.util.List; import org.springframework.data.jpa.repository.JpaRepository; -import org.springframework.data.jpa.repository.query.Procedure; +import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; import com.iemr.common.data.grievance.GrievanceDetails; -import jakarta.transaction.Transactional; @Repository public interface GrievanceOutboundRepository extends JpaRepository { - @Transactional - @Procedure(procedureName = "Pr_Grievanceworklist") - List getGrievanceWorklistData(@Param("providerServiceMapId") Integer providerServiceMapId, - @Param("userId") Integer userId); + + @Query(value =" call db_iemr.Pr_Grievanceworklist(:providerServiceMapID, :userId)", nativeQuery = true) + List getGrievanceWorklistData(@Param("providerServiceMapID") Integer providerServiceMapID, + @Param("userId") Integer userId); } diff --git a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java index b7546fea..f0798533 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -1,5 +1,6 @@ package com.iemr.common.service.grievance; +import java.sql.Timestamp; import java.util.List; import java.util.Map; @@ -8,8 +9,14 @@ import com.iemr.common.utils.exception.IEMRException; public interface GrievanceDataSync { - public List> dataSyncToGrievance(); +// public List> dataSyncToGrievance(); - public String fetchUnallocatedGrievanceCount(String preferredLanguage) throws IEMRException, JSONException; + public String dataSyncToGrievance(); + + + public String fetchUnallocatedGrievanceCount(String preferredLanguage, Timestamp filterStartDate, + Timestamp filterEndDate, Integer providerServiceMapID) throws IEMRException, JSONException; + + public String completeGrievanceCall(String request) throws Exception; } diff --git a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java index b93c2721..113a6c7c 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -6,6 +6,7 @@ import java.util.Calendar; import java.util.Date; import java.util.HashMap; +import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; @@ -29,12 +30,15 @@ import org.springframework.util.MultiValueMap; import org.springframework.web.client.RestTemplate; +import com.google.gson.JsonArray; import com.google.gson.JsonElement; import com.google.gson.JsonObject; import com.google.gson.JsonParser; +import com.iemr.common.data.callhandling.CallType; +import com.iemr.common.data.grievance.GrievanceCallRequest; import com.iemr.common.data.grievance.GrievanceDetails; import com.iemr.common.data.grievance.GrievanceTransaction; - +import com.iemr.common.repository.callhandling.IEMRCalltypeRepositoryImplCustom; import com.iemr.common.repository.grievance.GrievanceDataRepo; import com.iemr.common.repository.grievance.GrievanceFetchBenDetailsRepo; import com.iemr.common.repository.grievance.GrievanceTransactionRepo; @@ -42,6 +46,8 @@ import com.iemr.common.utils.exception.IEMRException; import com.iemr.common.utils.mapper.InputMapper; +import jakarta.transaction.Transactional; + @Service @PropertySource("classpath:application.properties") public class GrievanceDataSyncImpl implements GrievanceDataSync { @@ -55,23 +61,25 @@ public class GrievanceDataSyncImpl implements GrievanceDataSync { private static final String FILE_NAME = "fileName"; private static final String FILE_TYPE = "fileType"; - private static final String PREFERRED_LANGUAGE = "preferredLanguage"; - private static final String COUNT_OF_PREFERRED_LANGUAGE = "countOfPrefLanguage"; + private static final String PREFERRED_LANGUAGE = "language"; + private static final String COUNT_OF_PREFERRED_LANGUAGE = "count"; private final GrievanceDataRepo grievanceDataRepo; private final GrievanceTransactionRepo grievanceTransactionRepo; private final GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo; private final LocationStateRepository locationStateRepository; + private final IEMRCalltypeRepositoryImplCustom iEMRCalltypeRepositoryImplCustom; // Constructor-based injection @Autowired public GrievanceDataSyncImpl(GrievanceDataRepo grievanceDataRepo, GrievanceTransactionRepo grievanceTransactionRepo, GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo, - LocationStateRepository locationStateRepository) { + LocationStateRepository locationStateRepository, IEMRCalltypeRepositoryImplCustom iEMRCalltypeRepositoryImplCustom) { this.grievanceDataRepo = grievanceDataRepo; this.grievanceTransactionRepo = grievanceTransactionRepo; this.grievanceFetchBenDetailsRepo = grievanceFetchBenDetailsRepo; this.locationStateRepository = locationStateRepository; + this.iEMRCalltypeRepositoryImplCustom = iEMRCalltypeRepositoryImplCustom; } @Value("${grievanceUserAuthenticate}") @@ -92,15 +100,31 @@ public GrievanceDataSyncImpl(GrievanceDataRepo grievanceDataRepo, GrievanceTrans @Value("${grievanceDataSyncDuration}") private String grievanceDataSyncDuration; + @Value("${grievanceAllocationRetryConfiguration}") + private int grievanceAllocationRetryConfiguration; + private String GRIEVANCE_AUTH_TOKEN; private Long GRIEVANCE_TOKEN_EXP; - public List> dataSyncToGrievance() { + //public List> dataSyncToGrievance() { + public String dataSyncToGrievance() { + int count = 0; String registeringUser = ""; List> responseData = new ArrayList<>(); - List grievanceDetailsListAS = null; + List grievanceDetailsListAS = new ArrayList<>(); + // List grievanceDetailsListAS = new ArrayList<>(); + List grievanceDetailsListAll = new ArrayList<>(); + + List grievanceTransactionList = new ArrayList<>(); + // GrievanceTransaction grievanceTransaction = new GrievanceTransaction(); + GrievanceTransaction grievanceTransactionListObj = new GrievanceTransaction(); + List grievanceIds = new ArrayList<>(); // List to collect all grievance IDs + + + Long gwid; + try { // Loop to fetch data for multiple pages while (count >= 0) { @@ -118,6 +142,7 @@ public List> dataSyncToGrievance() { headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); headers.add(USER_AGENT_HEADER, USER_AGENT_VALUE); headers.add("AUTHORIZATION", GRIEVANCE_AUTH_TOKEN); + //headers.add("Authorization", "Bearer " + GRIEVANCE_AUTH_TOKEN); Date date = new Date(); java.sql.Date sqlDate = new java.sql.Date(date.getTime()); @@ -134,26 +159,38 @@ public List> dataSyncToGrievance() { if (response != null && response.hasBody()) { JSONObject obj = new JSONObject(response.getBody()); - if (obj != null && obj.has("data") && obj.has(STATUS_CODE) && obj.getInt(STATUS_CODE) == 200) { - logger.info("Grievance data details response received successfully "); + //if (obj != null && obj.has("data") && obj.has(STATUS_CODE) && obj.getInt(STATUS_CODE) == 200) { + if (obj != null && obj.has("data") && obj.has("status") && obj.getInt("status") == 200) { + logger.info("Grievance data details response received successfully "); String responseStr = response.getBody(); JsonObject jsnOBJ = new JsonObject(); JsonParser jsnParser = new JsonParser(); JsonElement jsnElmnt = jsnParser.parse(responseStr); jsnOBJ = jsnElmnt.getAsJsonObject(); - JsonObject grievanceJsonData = jsnOBJ.getAsJsonObject("data"); + + // Handle "data" as a JsonArray + JsonArray grievanceJsonDataArray = jsnOBJ.getAsJsonArray("data"); + // registeringUser = grievanceJsonDataArray.get(0).getAsJsonObject().get("userName").getAsString(); + + // registeringUser = grievanceJsonData.get("userName").getAsString(); + + + // if (Integer.parseInt(jsnOBJ.get("TotalRecords").toString()) > 0) { + if (Integer.parseInt(jsnOBJ.get("total").toString()) > 0) { - registeringUser = grievanceJsonData.get("userName").getAsString(); - if (Integer.parseInt(jsnOBJ.get("TotalRecords").toString()) > 0) { - GrievanceDetails[] grievanceDetailsArray = InputMapper.gson() - .fromJson(jsnOBJ.get("Data").toString(), GrievanceDetails[].class); - List grievanceDetailsList = Arrays.asList(grievanceDetailsArray); + List grievanceDetailsList = new ArrayList<>(); + + + // Iterate over the data array + for (JsonElement grievanceElement : grievanceJsonDataArray) { + JsonObject grievanceJsonData = grievanceElement.getAsJsonObject(); + + + GrievanceDetails grievance = new GrievanceDetails(); - ////////////////////// // Loop through the fetched grievance list and integrate transaction details - for (GrievanceDetails grievance : grievanceDetailsList) { String complaintId = grievanceJsonData.get("complainId").getAsString(); String formattedComplaintId = complaintId.replace("\\/", "/"); @@ -163,67 +200,54 @@ public List> dataSyncToGrievance() { throw new RuntimeException("Complaint ID " + formattedComplaintId + " already exists in the grievance worklist table."); } - + grievance.setComplaintID(formattedComplaintId); // Fetch related grievance transaction details - List transactionDetailsList = fetchGrievanceTransactions( - grievance.getGrievanceId()); - - if (transactionDetailsList != null && !transactionDetailsList.isEmpty()) { - // Loop through each transaction and set individual properties - for (GrievanceTransaction transactionDetails : transactionDetailsList) { - - // Assuming transactionDetailsJson is the JSON object representing a single - // transaction from the API response - JsonObject transactionDetailsJson = grievanceJsonData - .getAsJsonObject("transactionDetails"); // or another relevant path - - // Adding properties for each transaction detail - // Assuming these fields are coming from your API response - transactionDetails.setActionTakenBy( - transactionDetailsJson.get("actionTakenBy").getAsString()); - transactionDetails - .setStatus(transactionDetailsJson.get("status").getAsString()); - transactionDetails.setFileName(transactionDetailsJson.has(FILE_NAME) - ? transactionDetailsJson.get(FILE_NAME).getAsString() - : null); - transactionDetails.setFileType(transactionDetailsJson.has(FILE_TYPE) - ? transactionDetailsJson.get(FILE_TYPE).getAsString() - : null); - transactionDetails - .setRedressed(transactionDetailsJson.get("redressed").getAsString()); - transactionDetails.setCreatedAt(Timestamp - .valueOf(transactionDetailsJson.get("createdAt").getAsString())); - transactionDetails.setUpdatedAt(Timestamp - .valueOf(transactionDetailsJson.get("updatedAt").getAsString())); - transactionDetails - .setComment(transactionDetailsJson.get("comment").getAsString()); - - // Save individual transaction detail in the t_grievance_transaction table - grievanceTransactionRepo.save(transactionDetails); - } - - // Add the transaction list to the grievance object - grievance.setGrievanceTransactionDetails(transactionDetailsList); - } - - // Adding other grievance-related fields (similar to the existing code) - grievance.setSubjectOfComplaint(grievanceJsonData.get("subject").getAsString()); + Long grievanceID = grievanceJsonData.get("grievanceId").getAsLong(); + grievance.setGrievanceId(grievanceID); + grievanceIds.add(grievanceJsonData.get("grievanceId").getAsLong()); + + + // Adding other grievance-related fields + + grievance.setSubjectOfComplaint(grievanceJsonData.has("subject") && !grievanceJsonData.get("subject").isJsonNull() + ? grievanceJsonData.get("subject").getAsString() : null); ArrayList lists = grievanceFetchBenDetailsRepo .findByComplaintId(formattedComplaintId); - + grievance.setComplaint(grievanceJsonData.has("Complaint") + ? grievanceJsonData.get("Complaint").getAsString() : null); + String severityName = grievanceJsonData.has("severity") && grievanceJsonData.get("severity").getAsJsonObject().has("severity") + ? grievanceJsonData.get("severity").getAsJsonObject().get("severity").getAsString() + : null; + grievance.setSeverety(severityName); + + // Setting Level + Integer levelId = grievanceJsonData.has("level") && grievanceJsonData.get("level").getAsJsonObject().has("levelId") + ? grievanceJsonData.get("level").getAsJsonObject().get("levelId").getAsInt() + : null; + grievance.setLevel(levelId); + + // Setting state + String stateName = grievanceJsonData.has("state") && grievanceJsonData.get("state").getAsJsonObject().has("stateName") + ? grievanceJsonData.get("state").getAsJsonObject().get("stateName").getAsString() + : null; + grievance.setState(stateName);; for (Object[] objects : lists) { if (objects != null && objects.length <= 4) { grievance.setComplaintID((String) objects[0]); - grievance.setBeneficiaryRegID((Long) objects[1]); - grievance.setBenCallID((Long) objects[2]); + grievance.setBenCallID((Long) objects[1]); + grievance.setBeneficiaryRegID((Long) objects[2]); grievance.setProviderServiceMapID((Integer) objects[3]); - String state = locationStateRepository - .findByStateIDForGrievance((Integer) objects[4]); - grievance.setState(state); + // String state = locationStateRepository + // .findByStateIDForGrievance((Integer) objects[4]); + // grievance.setState(state); } } + + + + // setting language related properties and other ArrayList list1 = grievanceDataRepo .getBeneficiaryGrievanceDetails(grievance.getBeneficiaryRegID()); @@ -231,7 +255,7 @@ public List> dataSyncToGrievance() { if (objects != null && objects.length >= 6) { grievance.setPreferredLanguageId((Integer) objects[0]); grievance.setPreferredLanguage((String) objects[1]); - grievance.setVanSerialNo((Integer) objects[2]); + grievance.setVanSerialNo((Long) objects[2]); grievance.setVanID((Integer) objects[3]); grievance.setParkingPlaceID((Integer) objects[4]); grievance.setVehicalNo((String) objects[5]); @@ -239,62 +263,120 @@ public List> dataSyncToGrievance() { } } + String phoneNum = grievanceDataRepo.getPrimaryNumber(grievance.getBeneficiaryRegID()); + grievance.setPrimaryNumber(phoneNum); + // Setting remaining grievance properties (similar to the existing code) - grievance.setAgentid(grievance.getAgentid()); + // grievance.setAgentid(grievance.getAgentid()); grievance.setDeleted(grievance.getDeleted()); - grievance.setCreatedBy(registeringUser); + //grievance.setCreatedBy(registeringUser); + grievance.setCreatedBy("Admin"); grievance.setProcessed('N'); grievance.setIsAllocated(false); grievance.setCallCounter(0); grievance.setRetryNeeded(true); + + grievanceDetailsList.add(grievance); + } + // Add all new grievances to the main list + grievanceDetailsListAll.addAll(grievanceDetailsList); // Save the grievance details to the t_grievance table grievanceDetailsListAS = (List) grievanceDataRepo - .saveAll(grievanceDetailsList); + .saveAll(grievanceDetailsListAll); + + for (Long grievanceIdObj : grievanceIds) { + + JsonArray transactionDetailsList = fetchGrievanceTransactions(grievanceIdObj); - // Combine grievance and transaction data for response + if (transactionDetailsList != null && !transactionDetailsList.isEmpty()) { + // Loop through each transaction and set individual properties + for (JsonElement transactionElement : transactionDetailsList) { + JsonObject transactionDetailsJson = transactionElement.getAsJsonObject(); + GrievanceTransaction grievanceTransaction = new GrievanceTransaction(); + gwid = grievanceDataRepo.getUniqueGwid(grievanceIdObj); + grievanceTransaction.setGwid(gwid); + grievanceTransaction.setGrievanceId(grievanceIdObj); + + + grievanceTransaction.setActionTakenBy(transactionDetailsJson.has("actionTakenBy") + ? transactionDetailsJson.get("actionTakenBy").getAsString() + : null); + grievanceTransaction.setStatus(transactionDetailsJson.has("status") + ? transactionDetailsJson.get("status").getAsString() + : null); + grievanceTransaction.setFileName(transactionDetailsJson.has(FILE_NAME) + ? transactionDetailsJson.get(FILE_NAME).getAsString() + : null); + grievanceTransaction.setFileType(transactionDetailsJson.has(FILE_TYPE) + ? transactionDetailsJson.get(FILE_TYPE).getAsString() + : null); + grievanceTransaction.setRedressed(transactionDetailsJson.has("redressed") + ? transactionDetailsJson.get("redressed").getAsString() + : null); + grievanceTransaction.setCreatedAt(Timestamp + .valueOf(transactionDetailsJson.get("createdAt").getAsString())); + grievanceTransaction.setUpdatedAt(Timestamp + .valueOf(transactionDetailsJson.get("updatedAt").getAsString())); + grievanceTransaction.setComments(transactionDetailsJson.has("comment") + ? transactionDetailsJson.get("comment").getAsString() + : null); + grievanceTransaction.setCreatedBy("Admin"); + Timestamp timestamp = new Timestamp(System.currentTimeMillis()); + grievanceTransaction.setCreatedDate(timestamp); + + // Save individual transaction detail in the t_grievance_transaction table + grievanceTransactionListObj = grievanceTransactionRepo.save(grievanceTransaction); + grievanceTransactionList.add(grievanceTransactionListObj); + } - for (GrievanceDetails grievance : grievanceDetailsListAS) { - Map combinedData = new HashMap<>(); - combinedData.put("complaintID", grievance.getGrievanceId()); - combinedData.put("subjectOfComplaint", grievance.getSubjectOfComplaint()); - combinedData.put("complaint", grievance.getComplaint()); - combinedData.put("beneficiaryRegID", grievance.getBeneficiaryRegID()); - combinedData.put("providerServiceMapId", grievance.getProviderServiceMapID()); - - combinedData.put("primaryNumber", grievance.getPrimaryNumber()); - - // Add transaction data - List> transactions = new ArrayList<>(); - for (GrievanceTransaction transaction : grievance.getGrievanceTransactionDetails()) { - Map transactionData = new HashMap<>(); - transactionData.put("actionTakenBy", transaction.getActionTakenBy()); - transactionData.put("status", transaction.getStatus()); - transactionData.put(FILE_NAME, transaction.getFileName()); - transactionData.put(FILE_TYPE, transaction.getFileType()); - transactionData.put("redressed", transaction.getRedressed()); - transactionData.put("createdAt", transaction.getCreatedAt().toString()); - transactionData.put("updatedAt", transaction.getUpdatedAt().toString()); - transactionData.put("comment", transaction.getComment()); - transactions.add(transactionData); + // Add the transaction list to the grievance object + // grievance.setGrievanceTransactionDetails(grievanceTransactionList); } - - combinedData.put("transaction", transactions); - combinedData.put("severity", grievance.getSeverety()); - combinedData.put("state", grievance.getState()); - combinedData.put("agentId", grievance.getAgentid()); - combinedData.put("deleted", grievance.getDeleted()); - combinedData.put("createdBy", grievance.getCreatedBy()); - combinedData.put("createdDate", grievance.getCreatedDate()); - combinedData.put("lastModDate", grievance.getLastModDate()); - combinedData.put("isCompleted", grievance.getIsCompleted()); - - combinedData.put("retryNeeded", grievance.getRetryNeeded()); - combinedData.put("callCounter", grievance.getCallCounter()); - - responseData.add(combinedData); } + // Combine grievance and transaction data for response +// +// for (GrievanceDetails grievanceValue : grievanceDetailsListAS) { +// Map combinedData = new HashMap<>(); +// combinedData.put("complaintID", grievanceValue.getGrievanceId()); +// combinedData.put("subjectOfComplaint", grievanceValue.getSubjectOfComplaint()); +// combinedData.put("complaint", grievanceValue.getComplaint()); +// combinedData.put("beneficiaryRegID", grievanceValue.getBeneficiaryRegID()); +// combinedData.put("providerServiceMapId", grievanceValue.getProviderServiceMapID()); +// +// combinedData.put("primaryNumber", grievanceValue.getPrimaryNumber()); +// +// // Add transaction data +// List> transactions = new ArrayList<>(); +// for (GrievanceTransaction transaction : grievanceValue.getGrievanceTransactionDetails()) { +// Map transactionData = new HashMap<>(); +// //transactionData.put("actionTakenBy", transaction.getActionTakenBy()); +// // transactionData.put("status", transaction.getStatus()); +// transactionData.put(FILE_NAME, transaction.getFileName()); +// transactionData.put(FILE_TYPE, transaction.getFileType()); +// transactionData.put("redressed", transaction.getRedressed()); +// transactionData.put("createdAt", transaction.getCreatedAt().toString()); +// transactionData.put("updatedAt", transaction.getUpdatedAt().toString()); +// transactionData.put("comments", transaction.getComments()); +// transactions.add(transactionData); +// } +// +// combinedData.put("transaction", transactions); +// combinedData.put("severity", grievanceValue.getSeverety()); +// combinedData.put("state", grievanceValue.getState()); +// // combinedData.put("agentId", grievanceValue.getAgentid()); +// combinedData.put("deleted", grievanceValue.getDeleted()); +// combinedData.put("createdBy", grievanceValue.getCreatedBy()); +// combinedData.put("createdDate", grievanceValue.getCreatedDate()); +// combinedData.put("lastModDate", grievanceValue.getLastModDate()); +// combinedData.put("isCompleted", grievanceValue.getIsCompleted()); +// +// combinedData.put("retryNeeded", grievanceValue.getRetryNeeded()); +// combinedData.put("callCounter", grievanceValue.getCallCounter()); +// +// responseData.add(combinedData); +// } // Return the combined response as required @@ -308,11 +390,13 @@ public List> dataSyncToGrievance() { } catch (Exception e) { logger.error("Error in saving data into t_grievanceworklist: ", e); } - return responseData; + // return responseData; + return "Grievance Data saved successfully"; } - private List fetchGrievanceTransactions(Long grievanceId) { + private JsonArray fetchGrievanceTransactions(Long grievanceId) { List transactionDetailsList = new ArrayList<>(); + JsonArray transactionDataArray = new JsonArray(); try { HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); @@ -323,24 +407,30 @@ private List fetchGrievanceTransactions(Long grievanceId) RestTemplate restTemplate = new RestTemplate(); ResponseEntity response = restTemplate.exchange(updateGrievanceTransactionDetails + grievanceId, - HttpMethod.POST, request, String.class); + HttpMethod.GET, request, String.class); if (response != null && response.hasBody()) { JSONObject obj = new JSONObject(response.getBody()); - if (obj != null && obj.has("data") && obj.has(STATUS_CODE) && obj.getInt(STATUS_CODE) == 200) { + if (obj != null && obj.has("data") && obj.has("status") && obj.getInt("status") == 200) { JsonObject jsnOBJ = new JsonObject(); JsonParser jsnParser = new JsonParser(); JsonElement jsnElmnt = jsnParser.parse(response.getBody()); jsnOBJ = jsnElmnt.getAsJsonObject(); - GrievanceTransaction[] transactionDetailsArray = InputMapper.gson() - .fromJson(jsnOBJ.get("Data").toString(), GrievanceTransaction[].class); - transactionDetailsList = Arrays.asList(transactionDetailsArray); - } + + + transactionDataArray = jsnOBJ.getAsJsonArray("data"); +// if (transactionDataArray != null && transactionDataArray.size() > 0) { +// GrievanceTransaction[] transactionDetailsArray = new Gson() +// .fromJson(transactionDataArray, GrievanceTransaction[].class); +// transactionDetailsList = Arrays.asList(transactionDetailsArray); +// } } + } + } catch (Exception e) { logger.error("Error fetching grievance transaction details for grievanceId " + grievanceId, e); } - return transactionDetailsList; + return transactionDataArray; } private void generateGrievanceAuthToken() { @@ -359,13 +449,39 @@ private void generateGrievanceAuthToken() { httpRequestEntity, String.class); if (responseEntity != null && responseEntity.getStatusCodeValue() == 200 && responseEntity.hasBody()) { +// JSONObject requestObj = new JSONObject(request); +// String complaintResolution = requestObj.optString("ComplaintResolution", null); +// String state = requestObj.optString("State", null); + String responseBody = responseEntity.getBody(); JsonObject jsnOBJ = new JsonObject(); JsonParser jsnParser = new JsonParser(); JsonElement jsnElmnt = jsnParser.parse(responseBody); jsnOBJ = jsnElmnt.getAsJsonObject(); - GRIEVANCE_AUTH_TOKEN = jsnOBJ.get("token_type").getAsString() + " " - + jsnOBJ.get("access_token").getAsString(); + + // Accessing the "data" object first + if (jsnOBJ.has("data")) { + JsonObject dataObj = jsnOBJ.getAsJsonObject("data"); + + // Now check for "token_type" and "access_token" inside the "data" object + if (dataObj.has("token_type") && dataObj.has("access_token")) { + String tokenType = dataObj.get("token_type").getAsString(); + String accessToken = dataObj.get("access_token").getAsString(); + GRIEVANCE_AUTH_TOKEN = tokenType + " " + accessToken; + } else { + logger.error("Missing token_type or access_token in 'data' object: {}", responseBody); + // Handle missing tokens gracefully + return; + } + } else { + logger.error("'data' object is missing in response: {}", responseBody); + return; + } + + + + // GRIEVANCE_AUTH_TOKEN = jsnOBJ.get("token_type").getAsString() + " " + // + jsnOBJ.get("access_token").getAsString(); JsonObject grievanceLoginJsonData = jsnOBJ.getAsJsonObject("data"); @@ -383,7 +499,8 @@ private void generateGrievanceAuthToken() { int count = 3; while (count > 0) { try { - List> savedGrievanceData = dataSyncToGrievance(); + // List> savedGrievanceData = dataSyncToGrievance(); + String savedGrievanceData = dataSyncToGrievance(); if (savedGrievanceData != null) break; else { @@ -402,11 +519,13 @@ private void generateGrievanceAuthToken() { } } - public String fetchUnallocatedGrievanceCount(String preferredLanguage) throws IEMRException, JSONException { + @Override + public String fetchUnallocatedGrievanceCount(String preferredLanguage, Timestamp filterStartDate, + Timestamp filterEndDate, Integer providerServiceMapID) throws IEMRException, JSONException { logger.debug("Request received for fetchUnallocatedGrievanceCount"); // Fetch all unallocated grievances count from the database - Set resultSet = grievanceDataRepo.fetchUnallocatedGrievanceCount(); + Set resultSet = grievanceDataRepo.fetchUnallocatedGrievanceCount(filterStartDate, filterEndDate); // Initialize the result JSON object to hold counts JSONObject result = new JSONObject(); @@ -468,4 +587,112 @@ public String fetchUnallocatedGrievanceCount(String preferredLanguage) throws IE return resultArray.toString(); } + + + @Override + @Transactional + public String completeGrievanceCall(String request) throws Exception { + + GrievanceCallRequest grievanceCallRequest = InputMapper.gson().fromJson(request, GrievanceCallRequest.class); + String complaintID = grievanceCallRequest.getComplaintID(); + Integer userID = grievanceCallRequest.getUserID(); + Boolean isCompleted = grievanceCallRequest.getIsCompleted(); + Long beneficiaryRegID = grievanceCallRequest.getBeneficiaryRegID(); + Integer callTypeID = grievanceCallRequest.getCallTypeID(); + Integer providerServiceMapID = grievanceCallRequest.getProviderServiceMapID(); + + CallType callTypeObj = new CallType(); + String response = "failure"; + int updateCount = 0; + int updateCallCounter = 0; + try { + + GrievanceDetails grievanceCallStatus = new GrievanceDetails(); + + List lists = grievanceDataRepo.getCallCounter(complaintID); + for (Object[] objects : lists) { + if (objects != null && objects.length >= 2) { + grievanceCallStatus.setCallCounter((Integer) objects[0]); + grievanceCallStatus.setRetryNeeded((Boolean)objects[1]); + } + } + + // Fetching CallDetails using BenCallID and CallTypeID + Set callTypesArray = new HashSet(); + callTypesArray = iEMRCalltypeRepositoryImplCustom.getCallDetails(callTypeID); + for (Object[] object : callTypesArray) + { + if (object != null && object.length >= 2) + { + callTypeObj.setCallGroupType((String) object[0]); + callTypeObj.setCallType((String) object[1]); + + } + + } + + String callGroupType = callTypeObj.getCallGroupType(); + String callType = callTypeObj.getCallType(); + + + // Logic for reattempt based on call group type and call type + + boolean isRetryNeeded = grievanceCallStatus.getRetryNeeded(); + if (callGroupType.equals("Valid")) { + // Conditions when no reattempt is needed + if (callType.equals("Valid") || callType.equals("Test Call")) { + isRetryNeeded = false; + } else if (callType.equals("Disconnected Call") || callType.equals("Serviced Call") || + callType.equals("Silent Call") || callType.equals("Call Back")) { + // Reattempt is needed for these call subtypes + isRetryNeeded = true; + } + } + if (callGroupType.equals("Invalid") && callType.equals("Wrong Number")) { + isRetryNeeded = false; + //isCompleted = true; + grievanceDataRepo.updateCompletedStatusInCall(isCompleted, isRetryNeeded, complaintID, userID, beneficiaryRegID, providerServiceMapID); + } + + // Check if max attempts (3) are reached + if (isRetryNeeded == true && grievanceCallStatus.getCallCounter() < grievanceAllocationRetryConfiguration) { + // Increment the call counter for reattempt + grievanceCallStatus.setCallCounter(grievanceCallStatus.getCallCounter() + 1); + // Update the retryNeeded flag + isRetryNeeded = true; + //isCompleted = false; + updateCallCounter = grievanceDataRepo.updateCallCounter(grievanceCallStatus.getCallCounter(), isRetryNeeded, grievanceCallRequest.getComplaintID(), + grievanceCallRequest.getBeneficiaryRegID(), grievanceCallRequest.getProviderServiceMapID(), + grievanceCallRequest.getUserID()); + // Return success when reattempt logic is applied successfully. The grievance call needs to be retried, and a reattempt is performed. + if (updateCallCounter > 0) + response = "Successfully closing call"; + else { + response = "failure in closing call"; + } + } else if (grievanceCallStatus.getCallCounter()== grievanceAllocationRetryConfiguration) { + // Max attempts reached, no further reattempt + isRetryNeeded = false; + //isCompleted = true; + updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, isRetryNeeded, complaintID, userID, beneficiaryRegID, providerServiceMapID); + response = "max_attempts_reached"; // Indicate that max attempts are reached + + + } else { + + response = "no_reattempt_needed"; // No reattempt needed + } + + + + } + catch (Exception e) { + response = "error: " + e.getMessage(); + } + + return response; // Return the response (either success or error message) + } + + + } diff --git a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java index 1f8ecd6a..c1a19866 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java @@ -20,4 +20,9 @@ public interface GrievanceHandlingService { public List getFormattedGrievanceData(String request) throws Exception; + public String saveComplaintResolution(String request) throws Exception; + + public String getGrievanceDetailsWithRemarks(String request) throws Exception; + + } diff --git a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java index f850f1f5..b930bce3 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -1,8 +1,13 @@ package com.iemr.common.service.grievance; import java.sql.Timestamp; +import java.text.ParseException; +import java.text.SimpleDateFormat; import java.util.ArrayList; +import java.util.Arrays; import java.util.Comparator; +import java.util.Date; +import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; @@ -16,13 +21,16 @@ import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; +import com.fasterxml.jackson.databind.ObjectMapper; import com.iemr.common.data.grievance.GetGrievanceWorklistRequest; import com.iemr.common.data.grievance.GrievanceAllocationRequest; import com.iemr.common.data.grievance.GrievanceDetails; import com.iemr.common.data.grievance.GrievanceReallocationRequest; +import com.iemr.common.data.grievance.GrievanceResponse; import com.iemr.common.data.grievance.MoveToBinRequest; import com.iemr.common.dto.grivance.GrievanceTransactionDTO; import com.iemr.common.dto.grivance.GrievanceWorklistDTO; +import com.iemr.common.repository.callhandling.BeneficiaryCallRepository; import com.iemr.common.repository.grievance.GrievanceDataRepo; import com.iemr.common.repository.grievance.GrievanceOutboundRepository; import com.iemr.common.utils.exception.IEMRException; @@ -37,11 +45,14 @@ public class GrievanceHandlingServiceImpl implements GrievanceHandlingService { private final GrievanceDataRepo grievanceDataRepo; private final GrievanceOutboundRepository grievanceOutboundRepo; + private final BeneficiaryCallRepository beneficiaryCallRepo; @Autowired - public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo, GrievanceOutboundRepository grievanceOutboundRepo) { + public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo, GrievanceOutboundRepository grievanceOutboundRepo, + BeneficiaryCallRepository beneficiaryCallRepo) { this.grievanceDataRepo = grievanceDataRepo; this.grievanceOutboundRepo = grievanceOutboundRepo; + this.beneficiaryCallRepo = beneficiaryCallRepo; } @Value("${grievanceAllocationRetryConfiguration}") @@ -50,63 +61,69 @@ public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo, Grievan // retry logic private InputMapper inputMapper = new InputMapper(); // InputMapper used to map the JSON request - + @Override public String allocateGrievances(String request) throws Exception { - // Step 1: Parse the request string into the appropriate - // GrievanceAllocationRequest object - GrievanceAllocationRequest allocationRequest = InputMapper.gson().fromJson(request, - GrievanceAllocationRequest.class); + // Step 1: Parse the request string into the appropriate GrievanceAllocationRequest object + GrievanceAllocationRequest allocationRequest = InputMapper.gson().fromJson(request, GrievanceAllocationRequest.class); // Step 2: Fetch grievances based on the start date, end date range, and // language List grievances = grievanceDataRepo.findGrievancesInDateRangeAndLanguage( allocationRequest.getStartDate(), allocationRequest.getEndDate(), - allocationRequest.getPreferredLanguage()); + allocationRequest.getLanguage()); if (grievances.isEmpty()) { throw new Exception("No grievances found in the given date range and language."); } - // Step 3: Sort grievances in ascending order based on creation date - grievances.sort(Comparator.comparing(GrievanceDetails::getCreatedDate)); - - // Step 4: Get the allocation parameters from the request - int totalAllocated = 0; - int userIndex = 0; - List userIds = allocationRequest.getUserID(); - int allocateNo = allocationRequest.getAllocateNo(); // Number of grievances to allocate per user - - for (int i = 0; i < grievances.size(); i++) { - Integer userId = userIds.get(userIndex); - GrievanceDetails grievance = grievances.get(i); + // Step 3: Get the allocation parameters from the request + List userIds = allocationRequest.getTouserID(); + int allocateNo = allocationRequest.getAllocateNo(); // Number of grievances to allocate per user - int rowsAffected = grievanceDataRepo.allocateGrievance(grievance.getGrievanceId(), userId); - if (rowsAffected > 0) { - totalAllocated++; - logger.debug("Allocated grievance ID {} to user ID {}", grievance.getGrievanceId(), userId); - } else { - logger.error("Failed to allocate grievance ID {} to user ID {}", grievance.getGrievanceId(), userId); - } + // Step 4: Initialize counters + int totalAllocated = 0; + int grievanceIndex = 0; // Start from the first grievance + int totalUsers = userIds.size(); + int totalGrievances = grievances.size(); + + // Step 5: Allocate grievances to users, ensuring each user gets exactly 'allocateNo' grievances + for (Integer userId : userIds) { + int allocatedToCurrentUser = 0; + + // Allocate 'allocateNo' grievances to the current user + while (allocatedToCurrentUser < allocateNo && grievanceIndex < totalGrievances) { + GrievanceDetails grievance = grievances.get(grievanceIndex); + + // Allocate the grievance to the user + int rowsAffected = grievanceDataRepo.allocateGrievance(grievance.getGrievanceId(), userId); + if (rowsAffected > 0) { + totalAllocated++; + logger.debug("Allocated grievance ID {} to user ID {}", grievance.getGrievanceId(), userId); + } else { + logger.error("Failed to allocate grievance ID {} to user ID {}", grievance.getGrievanceId(), userId); + } + + grievanceIndex++; // Move to the next grievance + allocatedToCurrentUser++; // Increment the number of grievances allocated to the current user + } - // Move to the next user after allocateNo grievances - if ((i + 1) % allocateNo == 0) { - userIndex = (userIndex + 1) % userIds.size(); - } - } + // If we have allocated the specified number of grievances, move on to the next user + } - // Step 6: Return a message with the total number of grievances allocated - return "Successfully allocated " + totalAllocated + " grievances to users."; + // Step 6: Return a message with the total number of grievances allocated + return "Successfully allocated " + allocateNo + " grievance to each user."; } + @Override public String allocatedGrievanceRecordsCount(String request) throws IEMRException, JSONException { GrievanceDetails grievanceRequest = InputMapper.gson().fromJson(request, GrievanceDetails.class); Integer providerServiceMapID = grievanceRequest.getProviderServiceMapID(); - Integer assignedUserID = grievanceRequest.getAssignedUserID(); + Integer userID = grievanceRequest.getUserID(); - Set resultSet = grievanceDataRepo.fetchGrievanceRecordsCount(providerServiceMapID, assignedUserID); + Set resultSet = grievanceDataRepo.fetchGrievanceRecordsCount(providerServiceMapID, userID); JSONObject result = new JSONObject(); result.put("All", 0); @@ -135,57 +152,61 @@ public String allocatedGrievanceRecordsCount(String request) throws IEMRExceptio return resultArray.toString(); } + + @Override public String reallocateGrievances(String request) throws Exception { - // Step 1: Parse the request string into the appropriate - // GrievanceReallocationRequest object - GrievanceReallocationRequest reallocationRequest = InputMapper.gson().fromJson(request, - GrievanceReallocationRequest.class); + // Step 1: Parse the request string into the appropriate GrievanceReallocationRequest object + GrievanceReallocationRequest reallocationRequest = InputMapper.gson().fromJson(request, GrievanceReallocationRequest.class); - // Step 2: Fetch grievances that are allocated to the 'fromUserId' and match the - // criteria - List grievances = grievanceDataRepo.findAllocatedGrievancesByUserAndLanguage( - reallocationRequest.getFromUserId(), reallocationRequest.getLanguage()); + // Step 2: Fetch grievances that are allocated to the 'fromUserId' and match the criteria + List grievances = grievanceDataRepo.findAllocatedGrievancesByUserAndLanguage( + reallocationRequest.getFromUserId(), reallocationRequest.getLanguage()); - if (grievances.isEmpty()) { - throw new Exception("No grievances found for the given user and language."); - } + if (grievances.isEmpty()) { + throw new Exception("No grievances found for the given user and language."); + } - // Step 3: Sort grievances in ascending order based on creation date - grievances.sort(Comparator.comparing(GrievanceDetails::getCreatedDate)); + // Step 3: Sort grievances in ascending order based on creation date + grievances.sort(Comparator.comparing(GrievanceDetails::getCreatedDate)); - // Step 4: Get the allocation parameters from the request - int totalReallocated = 0; - int userIndex = 0; - List toUserIds = reallocationRequest.getTouserID(); - int allocateNo = reallocationRequest.getAllocateNo(); // Number of grievances to reallocate per user + // Step 4: Get the allocation parameters from the request + int totalReallocated = 0; + int grievanceIndex = 0; // Start from the first grievance + List toUserIds = reallocationRequest.getTouserID(); + int allocateNo = reallocationRequest.getAllocateNo(); // Number of grievances to reallocate per user - // Step 5: Reallocate grievances to users in a round-robin fashion - for (int i = 0; i < grievances.size(); i++) { - if (i % allocateNo == 0 && userIndex < toUserIds.size()) { - // Reallocate to the next user when reaching the allocateNo threshold - Integer toUserId = toUserIds.get(userIndex); - GrievanceDetails grievance = grievances.get(i); + // Step 5: Reallocate grievances to users + for (Integer toUserId : toUserIds) { + int allocatedToCurrentUser = 0; - // Call the repository method to reallocate the grievance to the new user - int rowsAffected = grievanceDataRepo.reallocateGrievance(grievance.getGrievanceId(), toUserId); + // Reallocate 'allocateNo' grievances to the current user + while (allocatedToCurrentUser < allocateNo && grievanceIndex < grievances.size()) { + GrievanceDetails grievance = grievances.get(grievanceIndex); - if (rowsAffected > 0) { - totalReallocated++; - logger.debug("Reallocated grievance ID " + grievance.getGrievanceId() + " to user ID " + toUserId); - } else { - logger.error("Failed to reallocate grievance ID " + grievance.getGrievanceId() + " to user ID " - + toUserId); - } + // Call the repository method to reallocate the grievance to the new user + int rowsAffected = grievanceDataRepo.reallocateGrievance(grievance.getGrievanceId(), toUserId); - userIndex = (userIndex + 1) % toUserIds.size(); - } - } + if (rowsAffected > 0) { + totalReallocated++; + logger.debug("Reallocated grievance ID {} to user ID {}", grievance.getGrievanceId(), toUserId); + } else { + logger.error("Failed to reallocate grievance ID {} to user ID {}", grievance.getGrievanceId(), toUserId); + } + + grievanceIndex++; // Move to the next grievance + allocatedToCurrentUser++; // Increment the number of grievances reallocated to the current user + } + + // If the current user is allocated the specified number of grievances, move to the next user + } - // Step 6: Return a message with the total number of grievances reallocated - return "Successfully reallocated " + totalReallocated + " grievances to users."; + // Step 6: Return a message with the total number of grievances reallocated + return "Successfully reallocated " + totalReallocated + " grievance to user."; } + + @Override public String moveToBin(String request) throws Exception { // Step 1: Parse the request string into the appropriate MoveToBinRequest object @@ -194,7 +215,7 @@ public String moveToBin(String request) throws Exception { // Step 2: Fetch grievances based on assigned user, language // condition List grievances = grievanceDataRepo.findGrievancesByUserAndLanguage( - moveToBinRequest.getAssignedUserID(), moveToBinRequest.getPreferredLanguageName()); + moveToBinRequest.getUserID(), moveToBinRequest.getPreferredLanguageName()); if (grievances.isEmpty()) { throw new Exception("No grievances found for the given user, language, and condition."); @@ -219,23 +240,23 @@ public String moveToBin(String request) throws Exception { // Step 4: Unassign grievances from the user and "move them to bin" int totalUnassigned = 0; for (GrievanceDetails grievance : grievancesToMove) { - int rowsAffected = grievanceDataRepo.unassignGrievance(grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + grievance.setUserID(null); + int rowsAffected = grievanceDataRepo.unassignGrievance(grievance.getUserID(), grievance.getGwid()); if (rowsAffected > 0) { grievance.setIsAllocated(false); // Assuming there's a setter for this flag - int updateFlagResult = grievanceDataRepo.updateGrievanceAllocationStatus(grievance.getGrievanceId(), - false); + int updateFlagResult = grievanceDataRepo.updateGrievanceAllocationStatus(grievance.getGwid(), + grievance.getIsAllocated()); if (updateFlagResult > 0) { totalUnassigned++; - logger.debug("Unassigned grievance ID {} from user ID {}", grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + logger.debug("Unassigned grievance gwid {} from user ID {}", grievance.getGwid(), + moveToBinRequest.getUserID()); } else { - logger.error("Failed to unassign grievance ID {} from user ID {}", grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + logger.error("Failed to unassign grievance gwid {} from user ID {}", grievance.getGwid(), + moveToBinRequest.getUserID()); } } else { - logger.error("Failed to unassign grievance ID {} from user ID {}", grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + logger.error("Failed to unassign grievance gwid {} from user ID {}", grievance.getGwid(), + moveToBinRequest.getUserID()); } } @@ -273,22 +294,30 @@ public List getFormattedGrievanceData(String request) thro // Loop through the worklist data and format the response for (Object[] row : worklistData) { - if (row == null || row.length < 28) + if (row == null || row.length < 30) { logger.warn("invalid row data received"); continue; } + + // Handle age conversion from Double to "x years" format + String ageFormatted = null; // Default value for age if it's not available + if (row[25] != null) { + Long age = (Long) row[25]; + ageFormatted = age.intValue() + " years"; // Convert the age to integer and append " years" + } + GrievanceWorklistDTO grievance = new GrievanceWorklistDTO( (String) row[0], // complaintID (String) row[1], // subjectOfComplaint (String) row[2], // complaint (Long) row[3], // beneficiaryRegID (Integer) row[4],// providerServiceMapID - (String) row[5], // primaryNumber (String) row[20], // firstName (String) row[21], // lastName - + (String) row[5], // primaryNumber + new ArrayList<>(),// transactions (initially empty, will be populated later) (String) row[12], // severety (String) row[13], // state @@ -301,14 +330,17 @@ public List getFormattedGrievanceData(String request) thro (String) row[22], // gender (String) row[23], // district (Long) row[24], // beneficiaryID - (String) row[25], // age + // (Double) row[25], // age + ageFormatted, (Boolean) row[26], // retryNeeded - (Integer) row[27] // callCounter + (Integer) row[27], // callCounter + (Timestamp) row[17] //lastCall yet to fill ); // Extract transactions from the current row and add them to the grievance object GrievanceTransactionDTO transaction = new GrievanceTransactionDTO( - + (String) row[28], //actionTakenBy yet to fill + (String) row[29], //status yet to fill (String) row[6], // fileName (String) row[7], // fileType (String) row[8], // redressed @@ -326,4 +358,191 @@ public List getFormattedGrievanceData(String request) thro return formattedGrievances; } + + /** + * Saves the complaint resolution and remarks for a grievance. + * + * @param request JSON string containing complaint resolution details + * @return Success message if the update is successful + */ + + @Transactional + public String saveComplaintResolution(String request) throws Exception { + // Parse the request JSON into a GrievanceDetails object + GrievanceDetails grievanceRequest = InputMapper.gson().fromJson(request, GrievanceDetails.class); + + if (grievanceRequest.getComplaintID() == null || grievanceRequest.getComplaintID().trim().isEmpty()) { + throw new IllegalArgumentException("ComplaintID is required"); + } + if (grievanceRequest.getComplaintResolution() == null || grievanceRequest.getComplaintResolution().trim().isEmpty()) { + throw new IllegalArgumentException("ComplaintResolution is required"); + } + if (grievanceRequest.getBeneficiaryRegID() == null) { + throw new IllegalArgumentException("BeneficiaryRegID is required"); + } + if (grievanceRequest.getProviderServiceMapID() == null) { + throw new IllegalArgumentException("ProviderServiceMapID is required"); + } + if (grievanceRequest.getUserID() == null) { + throw new IllegalArgumentException("AssignedUserID is required"); + } + if (grievanceRequest.getCreatedBy() == null) { + throw new IllegalArgumentException("CreatedBy is required"); + } + if(grievanceRequest.getBenCallID() == null) { + throw new IllegalArgumentException("BencallId is required"); + } + // Extract values from the request + String complaintID = grievanceRequest.getComplaintID(); + String complaintResolution = grievanceRequest.getComplaintResolution(); + String remarks = grievanceRequest.getRemarks(); + Long beneficiaryRegID = grievanceRequest.getBeneficiaryRegID(); + Integer providerServiceMapID = grievanceRequest.getProviderServiceMapID(); + Integer userID = grievanceRequest.getUserID(); + String createdBy = grievanceRequest.getCreatedBy(); + Long benCallID = grievanceRequest.getBenCallID(); + + String modifiedBy = createdBy; + int updateCount = 0; + if (remarks == null) { + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, modifiedBy, benCallID, complaintID, + beneficiaryRegID, providerServiceMapID, userID); + logger.debug("updated complaint resolution without remarks for complaint id: {}", complaintID); + } + else { + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, modifiedBy, benCallID, complaintID, + beneficiaryRegID, providerServiceMapID, userID); + logger.debug("updated complaint resolution with remarks for complaint id: {}", complaintID); + + } + if (updateCount > 0) { + return "Complaint resolution updated successfully"; + } else { + throw new Exception("Failed to update complaint resolution"); + } + } + + + + + private Date parseDate(String dateStr) { + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + try { + return dateFormat.parse(dateStr); + } catch (ParseException e) { + logger.error("Error parsing date for grievance: " + dateStr, e); + throw new IllegalArgumentException("Invalid date format in request:"+ dateStr); + } } + + + @Override + public String getGrievanceDetailsWithRemarks(String request) throws Exception { + ObjectMapper objectMapper = new ObjectMapper(); + + try { + // Parsing request to get the filter parameters (State, ComplaintResolution, StartDate, EndDate) + JSONObject requestObj = new JSONObject(request); + String complaintResolution = requestObj.optString("ComplaintResolution", null); + String state = requestObj.optString("State", null); + String fromDate = requestObj.optString("StartDate"); + String toDate = requestObj.optString("EndDate"); + + if (fromDate == null || toDate == null) { + throw new IllegalArgumentException("fromDate and toDate are required"); + } + // Convert StartDate and EndDate to Date objects + Date startDateStr = parseDate(fromDate); + Date endDateStr = parseDate(toDate); + + List grievanceDetailsList = grievanceDataRepo.fetchGrievanceDetailsBasedOnParams(state, complaintResolution, startDateStr, endDateStr); // Fetch grievance details based on the request + + if (grievanceDetailsList == null || grievanceDetailsList.isEmpty()) { + return "No grievance details found for the provided request."; + } + + List grievanceResponseList = new ArrayList<>(); + + + // Determine if the complaintResolution is "resolved" or "unresolved" + for (GrievanceDetails grievance : grievanceDetailsList) { + GrievanceResponse grievanceResponse = new GrievanceResponse(); + + // Set basic grievance details + grievanceResponse.setGrievanceId(grievance.getGrievanceId()); + grievanceResponse.setComplaintID(grievance.getComplaintID()); + grievanceResponse.setPrimaryNumber(grievance.getPrimaryNumber()); + grievanceResponse.setComplaintResolution(grievance.getComplaintResolution()); + grievanceResponse.setCreatedDate(grievance.getCreatedDate()); + grievanceResponse.setLastModDate(grievance.getLastModDate()); + + // Fetch and set remarks based on complaintResolution value + String remarks = ""; + if ("unresolved".equalsIgnoreCase(complaintResolution)) { + // Fetch remarks from t_bencall by joining with t_grievanceworklist based on benRegId + remarks = fetchRemarksFromBenCallByComplaint(grievance.getComplaintID()); + } else if ("resolved".equalsIgnoreCase(complaintResolution)) { + // Fetch remarks from t_grievanceworklist + remarks = fetchRemarksFromGrievanceWorklist(grievance.getComplaintID()); + } else { + // Default: Fetch remarks based on the grievance's specific conditions (no specific resolution status) + String callRemarks = fetchRemarksFromBenCallByComplaint(grievance.getComplaintID()); + if(remarks != null && !remarks.startsWith("No remarks found")) { + remarks = callRemarks; + } + else { + remarks = fetchRemarksFromGrievanceWorklist(grievance.getComplaintID()); + + } + } + + grievanceResponse.setRemarks(remarks); + + // Add to response list + grievanceResponseList.add(grievanceResponse); + } + + // Convert the list of GrievanceResponse objects to JSON and return as a string + return objectMapper.writeValueAsString(grievanceResponseList); + + } catch (Exception e) { + logger.error("Error while getting grievance details with remarks: " + e.getMessage(), e); + throw new Exception("Error processing grievance request"); + } + } + + + + private String fetchRemarksFromBenCallByComplaint(String complaintID) throws Exception { + // Query t_grievanceworklist to fetch the benRegId based on complaintID + List grievanceWorklist = grievanceDataRepo.fetchGrievanceWorklistByComplaintID(complaintID); + + if (grievanceWorklist != null && !grievanceWorklist.isEmpty()) { + GrievanceDetails grievance = grievanceWorklist.get(0); + Long beneficiaryRegID = grievance.getBeneficiaryRegID(); // Fetch the beneficiaryRegID from the grievance + + // Query t_bencall to fetch remarks based on benRegId + List benCallResults = beneficiaryCallRepo.fetchBenCallRemarks(beneficiaryRegID); + + if (benCallResults != null && !benCallResults.isEmpty()) { + return (String) benCallResults.get(0)[0]; // Fetch the remarks + } + } + + return "No remarks found in t_bencall"; + } + + private String fetchRemarksFromGrievanceWorklist(String complaintID) throws JSONException { + // Query t_grievanceworklist to fetch remarks based on complaintID + List grievanceWorklistResults = grievanceDataRepo.fetchGrievanceWorklistRemarks(complaintID); + + if (grievanceWorklistResults != null && !grievanceWorklistResults.isEmpty()) { + // Assuming grievanceWorklistResults has a format like [remarks] for simplicity + return (String) grievanceWorklistResults.get(0)[0]; // Fetch the remarks + } + return "No remarks found in t_grievanceworklist"; + } + + +} +