From a7a9518b7a432a1e31270df03bc49239befc73d6 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 15 Oct 2024 23:34:46 -0700 Subject: [PATCH 01/71] adding changes related to encryption and decryption --- .../AESEncryptionDecryption.java | 113 ++++++++++++------ 1 file changed, 77 insertions(+), 36 deletions(-) diff --git a/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java b/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java index bd78368c..d0a730a0 100644 --- a/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java +++ b/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java @@ -1,73 +1,114 @@ package com.iemr.common.utils.aesencryption; import java.io.UnsupportedEncodingException; + import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; import java.util.Arrays; import java.util.Base64; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; +import javax.crypto.spec.GCMParameterSpec; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; -import com.iemr.common.encryption.exception.DecryptionException; -import com.iemr.common.encryption.exception.EncryptionException; import com.iemr.common.utils.aesencryption.AESEncryptionDecryption; @Component public class AESEncryptionDecryption { - private static Logger logger = LoggerFactory.getLogger(AESEncryptionDecryption.class); + + private Logger logger = LoggerFactory.getLogger(AESEncryptionDecryption.class); + private static SecretKeySpec secretKey; - private static byte[] key; - static final String SECRET = "amrith$%2022@&*piramal@@swasthya!#"; - public static void setKey(String myKey) { - MessageDigest sha = null; + private byte[] key; + + private final String secret = "amrith$%2022@&*piramal@@swasthya!#"; + + private static final int IV_SIZE = 12; + + private static final int TAG_SIZE = 128; + + private final String UTF_8 = "UTF-8"; + + public void setKey(String myKey) { + try { - key = myKey.getBytes("UTF-8"); - sha = MessageDigest.getInstance("SHA-512"); + + key = myKey.getBytes(UTF_8); + + MessageDigest sha = MessageDigest.getInstance("SHA-512"); + key = sha.digest(key); + key = Arrays.copyOf(key, 16); + secretKey = new SecretKeySpec(key, "AES"); + } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) { - logger.error("context", e); + + logger.error("context", e); + } + } + + public String encrypt(String strToEncrypt) throws Exception { + if (secretKey == null) + + setKey(secret); + + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + + // Generate IV + + byte[] iv = new byte[IV_SIZE]; + + SecureRandom random = new SecureRandom(); + + random.nextBytes(iv); + + cipher.init(Cipher.ENCRYPT_MODE, secretKey, new GCMParameterSpec(TAG_SIZE, iv)); + + byte[] encryptedBytes = cipher.doFinal(strToEncrypt.getBytes(UTF_8)); + + byte[] encryptedIvAndText = new byte[IV_SIZE + encryptedBytes.length]; + + System.arraycopy(iv, 0, encryptedIvAndText, 0, IV_SIZE); + + System.arraycopy(encryptedBytes, 0, encryptedIvAndText, IV_SIZE, encryptedBytes.length); + + return Base64.getEncoder().encodeToString(encryptedIvAndText); - public String encrypt(String strToEncrypt) throws EncryptionException { - String encryptedString=null; - try { - if (secretKey == null) - setKey(SECRET); - Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); - cipher.init(Cipher.ENCRYPT_MODE, secretKey); - encryptedString= Base64.getEncoder().encodeToString(cipher.doFinal(strToEncrypt.getBytes("UTF-8"))); - } catch (Exception e) { - logger.error("Error while encrypting: {}", e.toString()); - throw new EncryptionException("Error while encrypting: "+e.toString(), e); - } - return encryptedString; } + + public String decrypt(String strToDecrypt) throws Exception { + if (secretKey == null) + + setKey(secret); + + byte[] encryptedIvAndText = Base64.getDecoder().decode(strToDecrypt); + + byte[] iv = Arrays.copyOfRange(encryptedIvAndText, 0, IV_SIZE); + + byte[] encryptedBytes = Arrays.copyOfRange(encryptedIvAndText, IV_SIZE, encryptedIvAndText.length); + + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + + cipher.init(Cipher.DECRYPT_MODE, secretKey, new GCMParameterSpec(TAG_SIZE, iv)); + + byte[] decryptedBytes = cipher.doFinal(encryptedBytes); + + return new String(decryptedBytes, UTF_8); - public String decrypt(String strToDecrypt) throws DecryptionException { - String decryptedString=null; - try { - if (secretKey == null) - setKey(SECRET); - Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); - cipher.init(Cipher.DECRYPT_MODE, secretKey); - decryptedString= new String(cipher.doFinal(Base64.getDecoder().decode(strToDecrypt))); - } catch (Exception e) { - logger.error("Error while decrypting: {}",e.toString()); - throw new DecryptionException("Error while decrypting: "+e.toString(), e); - } - return decryptedString; } + } From e1b53189a6a8dc8f1aa347fd50bd4e2c726c26a9 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 15 Oct 2024 23:42:56 -0700 Subject: [PATCH 02/71] making final field static --- .../common/utils/aesencryption/AESEncryptionDecryption.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java b/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java index d0a730a0..0fab3247 100644 --- a/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java +++ b/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java @@ -29,13 +29,13 @@ public class AESEncryptionDecryption { private byte[] key; - private final String secret = "amrith$%2022@&*piramal@@swasthya!#"; + private static final String secret = "amrith$%2022@&*piramal@@swasthya!#"; private static final int IV_SIZE = 12; private static final int TAG_SIZE = 128; - private final String UTF_8 = "UTF-8"; + private static final String UTF_8 = "UTF-8"; public void setKey(String myKey) { From eddabe303a59b4d9f181d22139db1319bc374542 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 15 Oct 2024 23:48:30 -0700 Subject: [PATCH 03/71] making enclosing method static --- .../utils/aesencryption/AESEncryptionDecryption.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java b/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java index 0fab3247..2c337d30 100644 --- a/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java +++ b/src/main/java/com/iemr/common/utils/aesencryption/AESEncryptionDecryption.java @@ -23,13 +23,13 @@ public class AESEncryptionDecryption { - private Logger logger = LoggerFactory.getLogger(AESEncryptionDecryption.class); + private static Logger logger = LoggerFactory.getLogger(AESEncryptionDecryption.class); private static SecretKeySpec secretKey; - private byte[] key; + private static byte[] key; - private static final String secret = "amrith$%2022@&*piramal@@swasthya!#"; + private static final String SECRET = "amrith$%2022@&*piramal@@swasthya!#"; private static final int IV_SIZE = 12; @@ -37,7 +37,7 @@ public class AESEncryptionDecryption { private static final String UTF_8 = "UTF-8"; - public void setKey(String myKey) { + public static void setKey(String myKey) { try { @@ -63,7 +63,7 @@ public String encrypt(String strToEncrypt) throws Exception { if (secretKey == null) - setKey(secret); + setKey(SECRET); Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); @@ -93,7 +93,7 @@ public String decrypt(String strToDecrypt) throws Exception { if (secretKey == null) - setKey(secret); + setKey(SECRET); byte[] encryptedIvAndText = Base64.getDecoder().decode(strToDecrypt); From 6e626bb73d41436b6fe4939546635728e5b22686 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 9 Dec 2024 23:55:33 -0800 Subject: [PATCH 04/71] adding beneficiaryConsent param to createFeedback API --- .../common/data/feedback/FeedbackDetails.java | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java b/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java index 40111ebd..b09c5dea 100644 --- a/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java +++ b/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java @@ -100,6 +100,10 @@ public class FeedbackDetails { @Transient private String instituteName = ""; + + @Column(name = "BeneficiaryConsent") + @Expose + private Boolean beneficiaryConsent; @Column(name = "DesignationID") @Expose @@ -304,7 +308,7 @@ public FeedbackDetails() { public FeedbackDetails(Long feedbackID, Long institutionID,String instiName, Integer designationID, Integer severityID, Integer feedbackTypeID, Integer feedbackStatusID, String feedback, Long beneficiaryRegID, Integer serviceID, Integer userID, String sMSPhoneNo, Timestamp serviceAvailDate, Boolean deleted, String createdBy, - Timestamp createdDate, String modifiedBy, Timestamp lastModDate, String feedbackAgainst) { + Timestamp createdDate, String modifiedBy, Timestamp lastModDate, String feedbackAgainst, Boolean beneficiaryConsent) { super(); this.feedbackID = feedbackID; this.institutionID = institutionID; @@ -325,7 +329,8 @@ public FeedbackDetails(Long feedbackID, Long institutionID,String instiName, Int this.modifiedBy = modifiedBy; this.lastModDate = lastModDate; this.feedbackAgainst = feedbackAgainst; - } + this.beneficiaryConsent = beneficiaryConsent; + } public FeedbackDetails(Long feedbackID, Integer severityID, Integer feedbackTypeID, Integer feedbackStatusID, String feedback, String createdBy, String feedbackAgainst) { @@ -466,6 +471,16 @@ public Boolean getDeleted() { public void setDeleted(Boolean deleted) { this.deleted = deleted; } + + public Boolean getbeneficiaryConsent() { + return beneficiaryConsent; + } + + public void setbeneficiaryConsent(Boolean beneficiaryConsent) { + this.beneficiaryConsent = beneficiaryConsent; + } + + public String getCreatedBy() { return createdBy; @@ -555,7 +570,7 @@ public static FeedbackDetails initializeFeedbackDetailsWithAllFeilds(Long feedba Integer stateID, States state, Integer districtID, Districts district, Integer blockID, DistrictBlock districtBlock, Integer districtBranchID, DistrictBranchMapping districtBranchMapping, Integer instituteTypeID, InstituteType instituteType, Integer feedbackNatureID, - FeedbackNatureDetail feedbackNatureDetail, String feedbackAgainst) { + FeedbackNatureDetail feedbackNatureDetail, String feedbackAgainst, Boolean beneficiaryConsent) { FeedbackDetails feedbackDetails = new FeedbackDetails(); feedbackDetails.feedbackID = feedbackID; feedbackDetails.mUser = mUser; @@ -624,6 +639,7 @@ public static FeedbackDetails initializeFeedbackDetailsWithAllFeilds(Long feedba feedbackDetails.feedbackNatureID = feedbackNatureID; feedbackDetails.feedbackNatureDetail = feedbackNatureDetail; feedbackDetails.feedbackAgainst = feedbackAgainst; + feedbackDetails.beneficiaryConsent = beneficiaryConsent; return feedbackDetails; } From 2303d6011ddde25e254908bf6519167eca36c0b7 Mon Sep 17 00:00:00 2001 From: Srishti gupta <76839176+srishtigrp78@users.noreply.github.com> Date: Tue, 10 Dec 2024 00:08:54 -0800 Subject: [PATCH 05/71] Update src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- .../java/com/iemr/common/data/feedback/FeedbackDetails.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java b/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java index b09c5dea..5ab9ea68 100644 --- a/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java +++ b/src/main/java/com/iemr/common/data/feedback/FeedbackDetails.java @@ -471,12 +471,11 @@ public Boolean getDeleted() { public void setDeleted(Boolean deleted) { this.deleted = deleted; } - - public Boolean getbeneficiaryConsent() { + public Boolean getBeneficiaryConsent() { return beneficiaryConsent; } - public void setbeneficiaryConsent(Boolean beneficiaryConsent) { + public void setBeneficiaryConsent(Boolean beneficiaryConsent) { this.beneficiaryConsent = beneficiaryConsent; } From b7718c06d52ce206f5eb951d6074f79ffee5ef33 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 10 Dec 2024 22:59:29 -0800 Subject: [PATCH 06/71] adding beneficiary consent param feedbacklist response --- .../com/iemr/common/model/feedback/FeedbackDetailsModel.java | 1 + .../iemr/common/model/feedback/FeedbackListResponseModel.java | 1 + .../com/iemr/common/model/feedback/FeedbackResponseModel.java | 1 + 3 files changed, 3 insertions(+) diff --git a/src/main/java/com/iemr/common/model/feedback/FeedbackDetailsModel.java b/src/main/java/com/iemr/common/model/feedback/FeedbackDetailsModel.java index 4f13209c..9bb2bfd9 100644 --- a/src/main/java/com/iemr/common/model/feedback/FeedbackDetailsModel.java +++ b/src/main/java/com/iemr/common/model/feedback/FeedbackDetailsModel.java @@ -99,4 +99,5 @@ public class FeedbackDetailsModel private String modifiedBy; private Timestamp lastModDate; private String feedbackAgainst; + private Boolean beneficiaryConsent; } diff --git a/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java b/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java index f5d1428b..6f2873cf 100644 --- a/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java +++ b/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java @@ -100,6 +100,7 @@ public class FeedbackListResponseModel { private String modifiedBy; private Timestamp lastModDate; private String feedbackAgainst; + private Boolean beneficiaryConsent; private String requestType; private EpidemicOutbreak epidemicOutbreak; diff --git a/src/main/java/com/iemr/common/model/feedback/FeedbackResponseModel.java b/src/main/java/com/iemr/common/model/feedback/FeedbackResponseModel.java index 27a92a2a..00c3a2ad 100644 --- a/src/main/java/com/iemr/common/model/feedback/FeedbackResponseModel.java +++ b/src/main/java/com/iemr/common/model/feedback/FeedbackResponseModel.java @@ -49,4 +49,5 @@ private Timestamp createdDate; private String modifiedBy; private Timestamp lastModDate; + private Boolean beneficiaryConsent; } From f9feef6d0a58715756a635d2abc96a0f78a57473 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 10 Dec 2024 23:01:00 -0800 Subject: [PATCH 07/71] adding space --- .../iemr/common/model/feedback/FeedbackListResponseModel.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java b/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java index 6f2873cf..eca4ec4c 100644 --- a/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java +++ b/src/main/java/com/iemr/common/model/feedback/FeedbackListResponseModel.java @@ -105,4 +105,5 @@ public class FeedbackListResponseModel { private String requestType; private EpidemicOutbreak epidemicOutbreak; private BalVivahComplaint balVivahComplaint; + } From 21be52e9b1aaa78b16c6736ca7b4249faceffe64 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Wed, 8 Jan 2025 22:49:47 -0800 Subject: [PATCH 08/71] adding code for schedule for grievance data sync --- .../common/config/quartz/QuartzConfig.java | 30 +- .../quartz/ScheduleForGrievanceDataSync.java | 33 ++ .../data/grievance/GrievanceDetails.java | 441 ++++++++++++++++++ .../data/grievance/GrievanceTransaction.java | 235 ++++++++++ .../grievance/GrievanceDataRepo.java | 23 + .../GrievanceFetchBenDetailsRepo.java | 20 + .../grievance/GrievanceTransactionRepo.java | 11 + .../location/LocationStateRepository.java | 5 + .../service/grievance/GrievanceDataSync.java | 8 + .../grievance/GrievanceDataSyncImpl.java | 402 ++++++++++++++++ 10 files changed, 1207 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java create mode 100644 src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java create mode 100644 src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java create mode 100644 src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java create mode 100644 src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java create mode 100644 src/main/java/com/iemr/common/repository/grievance/GrievanceTransactionRepo.java create mode 100644 src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java create mode 100644 src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java diff --git a/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java b/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java index 7c809917..468e9a4b 100644 --- a/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java +++ b/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java @@ -97,7 +97,8 @@ public SchedulerFactoryBean quartzScheduler() { Trigger[] triggers = { processMQTriggerForUnblock().getObject(), processMQTriggerForSMS().getObject(), processMQTriggerForEmail().getObject(), processMQTriggerForRegistration().getObject(), processMQTriggerForEverwellDataSync().getObject(), processMQTriggerForCtiDataSync().getObject(), - processMQTriggerForAvniRegistration().getObject(), processMQTriggerForNHMDashboardData().getObject() }; + processMQTriggerForAvniRegistration().getObject(), + processMQTriggerForNHMDashboardData().getObject(), processMQTriggerForGrievanceDataSync().getObject() }; quartzScheduler.setTriggers(triggers); @@ -226,6 +227,33 @@ public CronTriggerFactoryBean processMQTriggerForEverwellDataSync() { return cronTriggerFactoryBean; } + //-----------------Grievance Data Sync Scheduler---------------------------------------------- + + @Bean + public JobDetailFactoryBean processMQJobForGrievanceDataSync() { + JobDetailFactoryBean jobDetailFactory; + jobDetailFactory = new JobDetailFactoryBean(); + jobDetailFactory.setJobClass(ScheduleForGrievanceDataSync.class); + jobDetailFactory.setGroup(quartzJobGroup); + return jobDetailFactory; + } + + @Bean + public CronTriggerFactoryBean processMQTriggerForGrievanceDataSync() { + Boolean startJob = ConfigProperties.getBoolean("start-grievancedatasync-scheduler"); + CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean(); + String scheduleConfig = quartzJobDefaultSchedule; + if (startJob) { + scheduleConfig = ConfigProperties.getPropertyByName("cron-scheduler-grievancedatasync"); + } + cronTriggerFactoryBean.setJobDetail(processMQJobForGrievanceDataSync().getObject()); + cronTriggerFactoryBean.setCronExpression(scheduleConfig); + cronTriggerFactoryBean.setGroup(quartzJobGroup); + return cronTriggerFactoryBean; + } + + + // -------------------------------------------------------------------------------------------------------------- @Bean public JobDetailFactoryBean processMQJobForCtiDataSync() { diff --git a/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java b/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java new file mode 100644 index 00000000..f1d5a7dd --- /dev/null +++ b/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java @@ -0,0 +1,33 @@ +package com.iemr.common.config.quartz; + +import org.quartz.Job; +import org.quartz.JobExecutionContext; +import org.quartz.JobExecutionException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.iemr.common.service.grievance.GrievanceDataSync; + +@Service +@Transactional +public class ScheduleForGrievanceDataSync implements Job { + + private final Logger logger = LoggerFactory.getLogger(this.getClass().getName()); + + @Autowired + GrievanceDataSync grievanceDataSync; + + @Override + public void execute(JobExecutionContext arg0) throws JobExecutionException + { + logger.info("Started job for grievance data sync " + arg0.getClass().getName()); + grievanceDataSync.dataSyncToGrievance(); + logger.info("Completed job for grievance data sync " + arg0.getClass().getName()); + } + + + +} diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java new file mode 100644 index 00000000..70d1c154 --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -0,0 +1,441 @@ +package com.iemr.common.data.grievance; + +import java.sql.Timestamp; +import java.util.List; + +import com.google.gson.annotations.Expose; +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.Table; +import lombok.Data; + +@Entity +@Table(name = "t_grievanceworklist") +@Data +public class GrievanceDetails { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Expose + @Column(name = "GWID") + private Long gwid; + + @Expose + @Column(name = "Grievanceid") + private Long grievanceId; + + @Expose + @Column(name = "BeneficiaryRegID") + private Long beneficiaryRegID; + + @Column(name = "BenCallid") + @Expose + private Long benCallID; + + @Column(name = "ProviderServiceMapID") + @Expose + private Integer providerServiceMapID; + + @Expose + @Column(name = "ComplaintID") + private String complaintID; + + @Expose + @Column(name = "SubjectOfComplaint") + private String subjectOfComplaint; + + @Expose + @Column(name = "Complaint") + private String complaint; + + @Expose + @Column(name = "primaryNumber") + private String primaryNumber; + + @Expose + @Column(name = "Severety") + private String severety; + + @Expose + @Column(name = "Level") + private String level; + @Expose + @Column(name = "State") + private String state; + + @Expose + @Column(name = "Agentid") + private String agentid; + + @Expose + @Column(name = "userid") + private String userid; + + @Expose + @Column(name = "isAllocated") + private Boolean isAllocated = false; + + @Expose + @Column(name = "retryNeeded") + private Boolean retryNeeded; + + @Expose + @Column(name = "isRegistered") + private Boolean isRegistered = false; + + @Expose + @Column(name = "callCounter") + private Integer callCounter; + + @Column(name = "Deleted", insertable = false, updatable = true) + private Boolean deleted = false; + + @Expose + @Column(name = "Processed") + private Character Processed = 'N'; + + @Column(name = "CreatedBy") + @Expose + private String createdBy; + + @Expose + @Column(name = "CreatedDate", insertable = false, updatable = false) + private Timestamp createdDate; + + @Column(name = "ModifiedBy") + private String modifiedBy; + + @Column(name = "LastModDate", insertable = false, updatable = false) + private Timestamp lastModDate; + + @Expose + @Column(name = "VanSerialNo") + private Integer VanSerialNo; + @Expose + @Column(name = "VanID") + private Integer VanID; + + @Expose + @Column(name = "VehicalNo") + private String VehicalNo; + @Expose + @Column(name = "ParkingPlaceID") + private Integer ParkingPlaceID; + @Expose + @Column(name = "SyncedBy") + private String syncedBy; + + @Expose + @Column(name = "SyncedDate") + private Timestamp syncedDate; + + @Expose + @Column(name = "isCompleted") + private Boolean isCompleted = false; + + private List grievanceTransactionDetails; + + + 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, String userid, Boolean isAllocated, + Boolean retryNeeded, Boolean isRegistered, Integer callCounter, Boolean deleted, Character processed, + String createdBy, Timestamp createdDate, String modifiedBy, Timestamp lastModDate, Integer vanSerialNo, + Integer vanID, String vehicalNo, Integer parkingPlaceID, String syncedBy, Timestamp syncedDate, + Boolean isCompleted) { + super(); + this.gwid = gwid; + this.grievanceId = grievanceId; + this.beneficiaryRegID = beneficiaryRegID; + this.benCallID = benCallID; + this.providerServiceMapID = providerServiceMapID; + this.complaintID = complaintID; + this.subjectOfComplaint = subjectOfComplaint; + this.complaint = complaint; + this.primaryNumber = primaryNumber; + this.severety = severety; + this.state = state; + this.agentid = agentID; + this.userid = userid; + this.isAllocated = isAllocated; + this.retryNeeded = retryNeeded; + this.isRegistered = isRegistered; + this.callCounter = callCounter; + this.deleted = deleted; + this.Processed = processed; + this.createdBy = createdBy; + this.createdDate = createdDate; + this.modifiedBy = modifiedBy; + this.lastModDate = lastModDate; + this.VanSerialNo = vanSerialNo; + this.VanID = vanID; + this.VehicalNo = vehicalNo; + this.ParkingPlaceID = parkingPlaceID; + this.syncedBy = syncedBy; + this.syncedDate = syncedDate; + this.isCompleted = isCompleted; + } + + // Getters and Setters + public Long getGwid() { + return gwid; + } + + public void setGwid(Long gwid) { + this.gwid = gwid; + } + + public Long getGrievanceId() { + return grievanceId; + } + + public void setGrievanceId(Long grievanceId) { + this.grievanceId = grievanceId; + } + + public Long getBeneficiaryRegId() { + return beneficiaryRegID; + } + + public void setBeneficiaryRegId(Long beneficiaryRegId) { + this.beneficiaryRegID = beneficiaryRegId; + } + + public Long getBencallId() { + return benCallID; + } + + public void setBencallId(Long bencallId) { + this.benCallID = bencallId; + } + + public Integer getProviderServiceMapId() { + return providerServiceMapID; + } + + public void setProviderServiceMapId(Integer providerServiceMapId) { + this.providerServiceMapID = providerServiceMapId; + } + + public String getComplaintId() { + return complaintID; + } + + public void setComplaintId(String complaintId) { + this.complaintID = complaintId; + } + + public String getSubjectOfComplaint() { + return subjectOfComplaint; + } + + public void setSubjectOfComplaint(String subjectOfComplaint) { + this.subjectOfComplaint = subjectOfComplaint; + } + + public String getComplaint() { + return complaint; + } + + public void setComplaint(String complaint) { + this.complaint = complaint; + } + + public String getPrimaryNumber() { + return primaryNumber; + } + + public void setPrimaryNumber(String primaryNumber) { + this.primaryNumber = primaryNumber; + } + + public String getSeverety() { + return severety; + } + + public void setSeverity(String severety) { + this.severety = severety; + } + + public String getState() { + return state; + } + + public void setState(String state) { + this.state = state; + } + + public String getAgentId() { + return agentid; + } + + public void setAgentId(String agentId) { + this.agentid = agentId; + } + + public Boolean getIsRegistered() { + return isRegistered; + } + + public void setIsRegistered(Boolean isRegistered) { + this.isRegistered = isRegistered; + } + + public String getUserId() { + return userid; + } + + public void setUserId(String userId) { + this.userid = userId; + } + + public Boolean getIsAllocated() { + return isAllocated; + } + + public void setIsAllocated(Boolean isAllocated) { + this.isAllocated = isAllocated; + } + + public Boolean getRetryNeeded() { + return retryNeeded; + } + + public void setRetryNeeded(Boolean retryNeeded) { + this.retryNeeded = retryNeeded; + } + + public Integer getCallCounter() { + return callCounter; + } + + public void setCallCounter(Integer callCounter) { + this.callCounter = callCounter; + } + + public Boolean getDeleted() { + return deleted; + } + + public void setDeleted(Boolean deleted) { + this.deleted = deleted; + } + + public Character getProcessed() { + return Processed; + } + + public void setProcessed(Character processed) { + this.Processed = processed; + } + + public String getCreatedBy() { + return createdBy; + } + + public void setCreatedBy(String createdBy) { + this.createdBy = createdBy; + } + + public Timestamp getCreatedDate() { + return createdDate; + } + + public void setCreatedDate(Timestamp createdDate) { + this.createdDate = createdDate; + } + + public String getModifiedBy() { + return modifiedBy; + } + + public void setModifiedBy(String modifiedBy) { + this.modifiedBy = modifiedBy; + } + + public Timestamp getLastModDate() { + return lastModDate; + } + + public void setLastModDate(Timestamp lastModDate) { + this.lastModDate = lastModDate; + } + + public Integer getVanSerialNo() { + return VanSerialNo; + } + + public void setVanSerialNo(Integer vanSerialNo) { + this.VanSerialNo = vanSerialNo; + } + + public Integer getVanId() { + return VanID; + } + + public void setVanId(Integer vanId) { + this.VanID = vanId; + } + + public String getVehicleNo() { + return VehicalNo; + } + + public void setVehicleNo(String vehicleNo) { + this.VehicalNo = vehicleNo; + } + + public Integer getParkingPlaceId() { + return ParkingPlaceID; + } + + public void setParkingPlaceId(Integer parkingPlaceId) { + this.ParkingPlaceID = parkingPlaceId; + } + + public String getSyncedBy() { + return syncedBy; + } + + public void setSyncedBy(String syncedBy) { + this.syncedBy = syncedBy; + } + + public Timestamp getSyncedDate() { + return syncedDate; + } + + public void setSyncedDate(Timestamp syncedDate) { + this.syncedDate = syncedDate; + } + + public Boolean getIsCompleted() { + return isCompleted; + } + + public void setIsCompleted(Boolean isCompleted) { + this.isCompleted = isCompleted; + } + + + + // Getter for grievanceTransactionDetails + public List getGrievanceTransactionDetails() { + return grievanceTransactionDetails; + } + + // Setter for grievanceTransactionDetails + public void setGrievanceTransactionDetails(List grievanceTransactionDetails) { + this.grievanceTransactionDetails = grievanceTransactionDetails; + } + + + + +} + + \ No newline at end of file diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java new file mode 100644 index 00000000..e734f16a --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java @@ -0,0 +1,235 @@ +package com.iemr.common.data.grievance; + + +import javax.persistence.*; + +import com.google.gson.annotations.Expose; + +import lombok.Data; + +import java.util.Date; + +@Entity +@Data +@Table(name = "t_grievancetransaction") +public class GrievanceTransaction { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "gtid") + private Long gtid; + + @Column(name = "gwid", nullable = false) + @Expose + private Long gwid; + + @Column(name = "FileName", nullable = false, length = 500) + @Expose + private String fileName; + + @Column(name = "FileType", nullable = false, length = 300) + @Expose + private String fileType; + + @Column(name = "Redressed", nullable = false) + @Expose + private String redressed; + + @Column(name = "createdAt", nullable = false) + @Expose + private Date createdAt; + + @Column(name = "updatedAt", nullable = false) + @Expose + private Date updatedAt; + + @Column(name = "Comments", length = 500) + private String comments; + + @Column(name = "ProviderServiceMapID") + @Expose + private Integer providerServiceMapID; + + @Column(name = "Deleted", insertable = false, updatable = true) + @Expose + private Boolean deleted; + + @Column(name = "Processed", nullable = false) + @Expose + private String processed; + + + @Column(name = "ActionTakenBy") + @Expose + private String actionTakenBy; + + @Column(name = "Status") + @Expose + private String status; + + @Column(name = "Comment") + @Expose + private String comment; + + @Column(name = "CreatedBy", nullable = false) + @Expose + private String createdBy; + + @Column(name = "CreatedDate", nullable = false) + private Date createdDate; + + @Column(name = "ModifiedBy") + @Expose + private String modifiedBy; + + @Column(name = "LastModDate") + @Expose + private Date lastModDate; + + // Getters and Setters + + public Long getGtid() { + return gtid; + } + + public void setGtid(Long gtid) { + this.gtid = gtid; + } + + public Long getGwid() { + return gwid; + } + + public void setGwid(Long gwid) { + this.gwid = gwid; + } + + public String getFileName() { + return fileName; + } + + public void setFileName(String fileName) { + this.fileName = fileName; + } + + public String getFileType() { + return fileType; + } + + public void setFileType(String fileType) { + this.fileType = fileType; + } + + public String getRedressed() { + return redressed; + } + + public void setRedressed(String redressed) { + this.redressed = redressed; + } + + public Date getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(Date createdAt) { + this.createdAt = createdAt; + } + + public Date getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(Date updatedAt) { + this.updatedAt = updatedAt; + } + + public String getComments() { + return comments; + } + + public void setComments(String comments) { + this.comments = comments; + } + + public Integer getProviderServiceMapID() { + return providerServiceMapID; + } + + public void setProviderServiceMapID(Integer providerServiceMapID) { + this.providerServiceMapID = providerServiceMapID; + } + + public Boolean getDeleted() { + return deleted; + } + + public void setDeleted(Boolean deleted) { + this.deleted = deleted; + } + + public String getProcessed() { + return processed; + } + + public void setProcessed(String processed) { + this.processed = processed; + } + + public String getCreatedBy() { + return createdBy; + } + + public void setCreatedBy(String createdBy) { + this.createdBy = createdBy; + } + + public Date getCreatedDate() { + return createdDate; + } + + public void setCreatedDate(Date createdDate) { + this.createdDate = createdDate; + } + + public String getModifiedBy() { + return modifiedBy; + } + + public void setModifiedBy(String modifiedBy) { + this.modifiedBy = modifiedBy; + } + + public Date getLastModDate() { + return lastModDate; + } + + public void setLastModDate(Date lastModDate) { + this.lastModDate = lastModDate; + } + + public String getActionTakenBy( ) { + return actionTakenBy; + } + + public void setActionTakenBy(String actionTakenBy) { + this.actionTakenBy = actionTakenBy; + } + + public String getStatus( ) { + return status; + } + + public void setStatus(String status) { + this.status = status; + } + + public String comment( ) { + return comment; + } + + public void setComment(String comment ) { + this.comment = comment; + } +} + diff --git a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java new file mode 100644 index 00000000..a428c743 --- /dev/null +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -0,0 +1,23 @@ +package com.iemr.common.repository.grievance; + + + + +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.CrudRepository; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + + + +import com.iemr.common.data.grievance.GrievanceDetails; + +@Repository +public interface GrievanceDataRepo extends CrudRepository{ + + @Query("SELECT COUNT(g) > 0 FROM GrievanceDetails g WHERE g.complaintId = :complaintId") + boolean existsByComplaintId(@Param("complaintId") String complaintId); + + + +} diff --git a/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java new file mode 100644 index 00000000..09ce5a81 --- /dev/null +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java @@ -0,0 +1,20 @@ +package com.iemr.common.repository.grievance; + +import java.util.ArrayList; + +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.CrudRepository; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import com.iemr.common.data.feedback.FeedbackDetails; + + +@Repository +public interface GrievanceFetchBenDetailsRepo extends CrudRepository { + + @Query("select requestID, benCallID, beneficiaryRegID, providerServiceMapID, stateID " + + " from FeedbackDetails where requestID = :requestID order by requestID desc") + public ArrayList findByComplaintId(@Param("requestID") String requestID); + +} diff --git a/src/main/java/com/iemr/common/repository/grievance/GrievanceTransactionRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceTransactionRepo.java new file mode 100644 index 00000000..2c513836 --- /dev/null +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceTransactionRepo.java @@ -0,0 +1,11 @@ +package com.iemr.common.repository.grievance; + +import org.springframework.data.repository.CrudRepository; +import org.springframework.stereotype.Repository; + +import com.iemr.common.data.grievance.GrievanceTransaction; + +@Repository +public interface GrievanceTransactionRepo extends CrudRepository { + +} diff --git a/src/main/java/com/iemr/common/repository/location/LocationStateRepository.java b/src/main/java/com/iemr/common/repository/location/LocationStateRepository.java index 1685b46f..0555a467 100644 --- a/src/main/java/com/iemr/common/repository/location/LocationStateRepository.java +++ b/src/main/java/com/iemr/common/repository/location/LocationStateRepository.java @@ -50,4 +50,9 @@ public interface LocationStateRepository extends CrudRepository public String getStateLanguage(@Param("stateName") String stateName); States findByStateID(Integer stateID); + + @Query("select state from States state where state.stateID = :id") + public String findByStateIDForGrievance(@Param("id") int id); + + } diff --git a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java new file mode 100644 index 00000000..188e1cb5 --- /dev/null +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -0,0 +1,8 @@ +package com.iemr.common.service.grievance; + +import java.util.List; +import java.util.Map; + +public interface GrievanceDataSync { + public List> dataSyncToGrievance(); +} diff --git a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java new file mode 100644 index 00000000..8b3d3841 --- /dev/null +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -0,0 +1,402 @@ +package com.iemr.common.service.grievance; + + + + import java.sql.Timestamp; + import java.util.ArrayList; + import java.util.Arrays; + import java.util.Calendar; + import java.util.Date; + import java.util.HashMap; + import java.util.List; + import java.util.Map; + + import org.json.JSONObject; + import org.slf4j.Logger; + import org.slf4j.LoggerFactory; + import org.springframework.beans.factory.annotation.Autowired; + import org.springframework.beans.factory.annotation.Value; + import org.springframework.context.annotation.PropertySource; + import org.springframework.http.HttpEntity; + import org.springframework.http.HttpHeaders; + import org.springframework.http.HttpMethod; + import org.springframework.http.MediaType; + import org.springframework.http.ResponseEntity; + import org.springframework.stereotype.Service; + import org.springframework.util.LinkedMultiValueMap; + import org.springframework.util.MultiValueMap; + import org.springframework.web.client.RestTemplate; + + import com.google.gson.JsonElement; + import com.google.gson.JsonObject; + import com.google.gson.JsonParser; + import com.iemr.common.data.grievance.GrievanceDetails; + import com.iemr.common.data.grievance.GrievanceTransaction; + + import com.iemr.common.repository.grievance.GrievanceDataRepo; + import com.iemr.common.repository.grievance.GrievanceFetchBenDetailsRepo; + import com.iemr.common.repository.grievance.GrievanceTransactionRepo; + import com.iemr.common.repository.location.LocationStateRepository; + import com.iemr.common.utils.mapper.InputMapper; + +@Service +@PropertySource("classpath:application.properties") +public class GrievanceDataSyncImpl { + Logger logger = LoggerFactory.getLogger(this.getClass().getName()); + + RestTemplate restTemplateLogin = new RestTemplate(); + + @Autowired + private GrievanceDataRepo grievanceDataRepo; + + @Autowired + private GrievanceTransactionRepo grievanceTransactionRepo; + + @Autowired + private GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo; + + @Autowired + private LocationStateRepository locationStateRepository; + + @Value("${greivanceUserAuthenticate}") + private String grievanceUserAuthenticate; + + @Value("${updateGrievanceDetails}") + private String updateGrievanceDetails; + + @Value("${updateGrievanceTransactionDetails}") + private String updateGrievanceTransactionDetails; + + @Value("${grievanceUserName}") + private String grievanceUserName; + + @Value("${grievancePassword}") + private String grievancePassword; + + @Value("${grievanceDataSyncDuration}") + private String grievanceDataSyncDuration; + + private static String GRIEVANCE_AUTH_TOKEN; + private static Long GRIEVANCE_TOKEN_EXP; + + public List> dataSyncToGrievance(String grievanceAuthorization, String registeringUser, + String Authorization) { + + int count = 0; + List> responseData = new ArrayList<>(); + List grievanceDetailsListAS = null; + try { + // Loop to fetch data for multiple pages + while (count >= 0) { + RestTemplate restTemplate = new RestTemplate(); + + if (GRIEVANCE_AUTH_TOKEN != null && GRIEVANCE_TOKEN_EXP != null + && GRIEVANCE_TOKEN_EXP > System.currentTimeMillis()) { + // no need of calling auth API + } else { + // call method to generate Auth Token at Everwell end + generateGrievanceAuthToken(); + } + + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); + headers.add("user-agent", + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"); + headers.add("AUTHORIZATION", GRIEVANCE_AUTH_TOKEN); + + Date date = new Date(); + java.sql.Date sqlDate = new java.sql.Date(date.getTime()); + String text = sqlDate.toString(); + Timestamp currentDate = new Timestamp(sqlDate.getTime()); + Calendar calendar = Calendar.getInstance(); + calendar.setTime(sqlDate); + calendar.add(Calendar.DATE, -Integer.parseInt(grievanceDataSyncDuration)); + Date beforeDate = calendar.getTime(); + Timestamp lastDate = new Timestamp(beforeDate.getTime()); + + // Request object + HttpEntity request = new HttpEntity(headers); + + // Call rest-template to call API to download master data for given table + ResponseEntity response = restTemplate.exchange(updateGrievanceDetails, HttpMethod.POST, request, + String.class); + + if (response != null && response.hasBody()) { + JSONObject obj = new JSONObject(response.getBody()); + if (obj != null && obj.has("data") && obj.has("statusCode") && obj.getInt("statusCode") == 200) { + logger.info("Grievance data details response: " + response.getBody()); + + 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"); + + if (Integer.parseInt(jsnOBJ.get("TotalRecords").toString()) > 0) { + GrievanceDetails[] grievanceDetailsArray = InputMapper.gson().fromJson(jsnOBJ.get("Data").toString(), GrievanceDetails[].class); + List grievanceDetailsList = Arrays.asList(grievanceDetailsArray); + + // Fetch transaction details and integrate them with the grievance details +// for (GrievanceDetails grievance : grievanceDetailsList) { +// String complaintId = grievance.getGrievanceId(); +// String formattedComplaintId = complaintId.replace("\\/", "/"); +// grievance.setGrievanceId(formattedComplaintId); +// +// // Fetch related grievance transaction details +// List transactionDetailsList = fetchGrievanceTransactions(formattedComplaintId); +// +// if (transactionDetailsList != null && !transactionDetailsList.isEmpty()) { +// // Save transactions to the t_grievance_transaction table +// grievanceTransactionRepo.saveAll(transactionDetailsList); +// // Add the transaction list to the grievance object +// grievance.setGrievanceTransactionDetails(transactionDetailsList); +// } +// +// // Adding other grievance-related fields +// grievance.setSubjectOfComplaint(grievanceJsonData.get("subject").getAsString()); +// ArrayList lists = grievanceFetchBenDetailsRepo.findByComplaintId(formattedComplaintId); +// +// 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.setProviderServiceMapId((Integer) objects[3]); +// String state = locationStateRepository.findByStateIDForGrievance((Integer) objects[4]); +// grievance.setState(state); +// } +// } +// +// grievance.setAgentId(grievance.getAgentId()); +// grievance.setDeleted(grievance.getDeleted()); +// grievance.setCreatedBy(registeringUser); +// grievance.setProcessed('N'); +// grievance.setIsAllocated(false); +// grievance.setCallCounter(0); +// grievance.setRetryNeeded(true); +// } + + ////////////////////// + // Loop through the fetched grievance list and integrate transaction details + for (GrievanceDetails grievance : grievanceDetailsList) { + String complaintId = grievanceJsonData.get("complainId").getAsString(); + String formattedComplaintId = complaintId.replace("\\/", "/"); + + // Check if the complaintId is already present in the t_grievance_worklist table + boolean complaintExists = grievanceDataRepo.existsByComplaintId(formattedComplaintId); + if (complaintExists) { + throw new RuntimeException("Complaint ID " + formattedComplaintId + " already exists in the grievance worklist table."); + } + + + grievance.setComplaintId(formattedComplaintId); + + // Fetch related grievance transaction details + List transactionDetailsList = fetchGrievanceTransactions(formattedComplaintId); + + 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 + // transactionDetails.setComplaintId(formattedComplaintId); + // 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("fileName") ? transactionDetailsJson.get("fileName").getAsString() : null); + transactionDetails.setFileType(transactionDetailsJson.has("fileType") ? transactionDetailsJson.get("fileType").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()); + ArrayList lists = grievanceFetchBenDetailsRepo.findByComplaintId(formattedComplaintId); + + 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.setProviderServiceMapId((Integer) objects[3]); + String state = locationStateRepository.findByStateIDForGrievance((Integer) objects[4]); + grievance.setState(state); + } + } + + // Setting remaining grievance properties (similar to the existing code) + grievance.setAgentId(grievance.getAgentId()); + grievance.setDeleted(grievance.getDeleted()); + grievance.setCreatedBy(registeringUser); + grievance.setProcessed('N'); + grievance.setIsAllocated(false); + grievance.setCallCounter(0); + grievance.setRetryNeeded(true); + } + + // Save the grievance details to the t_grievance table + grievanceDetailsListAS = (List) grievanceDataRepo.saveAll(grievanceDetailsList); + + // Combine grievance and transaction data for response + + 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("firstName", grievance.getFirstName()); + // combinedData.put("lastName", grievance.getLastName()); + 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("fileName", transaction.getFileName()); + transactionData.put("fileType", 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); + } + + 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("gender", grievance.getGender()); + // combinedData.put("district", grievance.getDistrict()); + // combinedData.put("beneficiaryID", grievance.getBeneficiaryId()); + // combinedData.put("age", grievance.getAge()); + combinedData.put("retryNeeded", grievance.getRetryNeeded()); + combinedData.put("callCounter", grievance.getCallCounter()); + // combinedData.put("lastCall", grievance.getLastCall()); + + responseData.add(combinedData); + } + + + // Return the combined response as required + // return responseData; + + } else { + logger.info("No records found for page = " + count); + count = -1; + } + } + } + } + } catch (Exception e) { + logger.error("Error in saving data into t_grievanceworklist: ", e); + } + return responseData; + } + + private List fetchGrievanceTransactions(String complaintId) { + List transactionDetailsList = new ArrayList<>(); + try { + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); + headers.add("user-agent", + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"); + headers.add("AUTHORIZATION", GRIEVANCE_AUTH_TOKEN); + + HttpEntity request = new HttpEntity(headers); + RestTemplate restTemplate = new RestTemplate(); + ResponseEntity response = restTemplate.exchange(updateGrievanceTransactionDetails, HttpMethod.POST, request, String.class); + + if (response != null && response.hasBody()) { + JSONObject obj = new JSONObject(response.getBody()); + if (obj != null && obj.has("data") && obj.has("statusCode") && obj.getInt("statusCode") == 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); + } + } + } catch (Exception e) { + logger.error("Error fetching grievance transaction details for complaintId " + complaintId, e); + } + return transactionDetailsList; + } + + private void generateGrievanceAuthToken() { + String Authorization = ""; + String registeringUser = ""; + MultiValueMap requestData = new LinkedMultiValueMap(); + requestData.add("username", grievanceUserName); + requestData.add("password", grievancePassword); + requestData.add("grant_type", "password"); + HttpHeaders httpHeaders = new HttpHeaders(); + httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED); + httpHeaders.add("user-agent", + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"); + + HttpEntity> httpRequestEntity = new HttpEntity>( + requestData, httpHeaders); + ResponseEntity responseEntity = restTemplateLogin.exchange(grievanceUserAuthenticate, HttpMethod.POST, + httpRequestEntity, String.class); + + if (responseEntity != null && responseEntity.getStatusCodeValue() == 200 && responseEntity.hasBody()) { + 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(); + + JsonObject grievanceLoginJsonData = jsnOBJ.getAsJsonObject("data"); + Authorization = grievanceLoginJsonData.get("key").getAsString(); + registeringUser = grievanceLoginJsonData.get("userName").getAsString(); + + logger.info("Auth key generated at : " + System.currentTimeMillis() + ", Key : " + GRIEVANCE_AUTH_TOKEN); + + Date date = new Date(); + java.sql.Date sqlDate = new java.sql.Date(date.getTime()); + Calendar grievanceCalendar = Calendar.getInstance(); + grievanceCalendar.setTime(sqlDate); + grievanceCalendar.add(Calendar.DATE, 29); + Date grievanceTokenEndDate = grievanceCalendar.getTime(); + // setting Token expiry - 29 days + GRIEVANCE_TOKEN_EXP = grievanceTokenEndDate.getTime(); + + int count = 3; + while (count > 0) { + List> savedGrievanceData = dataSyncToGrievance(GRIEVANCE_AUTH_TOKEN, registeringUser, + Authorization); + if (savedGrievanceData != null) + break; + else + count--; + } + } + } + } + + From 0a90728019942e7066e6feedf9cd07d03bba8c92 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 04:23:52 -0800 Subject: [PATCH 09/71] adding code rabbit code suggestions --- .../data/grievance/GrievanceDetails.java | 6 ++++++ .../data/grievance/GrievanceTransaction.java | 4 ++++ .../GrievanceFetchBenDetailsRepo.java | 4 ++-- .../location/LocationStateRepository.java | 2 +- .../service/grievance/GrievanceDataSync.java | 3 ++- .../grievance/GrievanceDataSyncImpl.java | 21 ++++++++++++------- 6 files changed, 28 insertions(+), 12 deletions(-) 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 70d1c154..2e26201e 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -3,13 +3,17 @@ import java.sql.Timestamp; import java.util.List; +import com.fasterxml.jackson.annotation.JsonManagedReference; import com.google.gson.annotations.Expose; + +import jakarta.persistence.CascadeType; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.FetchType; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; +import jakarta.persistence.OneToMany; import jakarta.persistence.Table; import lombok.Data; @@ -137,6 +141,8 @@ public class GrievanceDetails { @Column(name = "isCompleted") private Boolean isCompleted = false; + @OneToMany(mappedBy = "grievanceDetails", cascade = CascadeType.ALL, fetch = FetchType.LAZY) + @JsonManagedReference private List grievanceTransactionDetails; 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 e734f16a..c6ebcd82 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java @@ -85,6 +85,10 @@ public class GrievanceTransaction { @Column(name = "LastModDate") @Expose private Date lastModDate; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "gwid", insertable = false, updatable = false) + private GrievanceDetails grievanceDetails; // Getters and Setters 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 09ce5a81..19b470f8 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java @@ -13,8 +13,8 @@ @Repository public interface GrievanceFetchBenDetailsRepo extends CrudRepository { - @Query("select requestID, benCallID, beneficiaryRegID, providerServiceMapID, stateID " - + " from FeedbackDetails where requestID = :requestID order by requestID desc") + @Query("select f.requestID, f.benCallID, f.beneficiaryRegID, f.providerServiceMapID, f.stateID " + + " 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/location/LocationStateRepository.java b/src/main/java/com/iemr/common/repository/location/LocationStateRepository.java index 0555a467..b6c7e8f6 100644 --- a/src/main/java/com/iemr/common/repository/location/LocationStateRepository.java +++ b/src/main/java/com/iemr/common/repository/location/LocationStateRepository.java @@ -51,7 +51,7 @@ public interface LocationStateRepository extends CrudRepository States findByStateID(Integer stateID); - @Query("select state from States state where state.stateID = :id") + @Query("select state.state from States state where state.stateID = :id") public String findByStateIDForGrievance(@Param("id") int id); 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 188e1cb5..9f98da4c 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -4,5 +4,6 @@ import java.util.Map; public interface GrievanceDataSync { - public List> dataSyncToGrievance(); + public List> dataSyncToGrievance(String grievanceAuthorization, String registeringUser, + String Authorization); } 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 8b3d3841..ba7b2733 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -41,7 +41,7 @@ @Service @PropertySource("classpath:application.properties") -public class GrievanceDataSyncImpl { +public class GrievanceDataSyncImpl implements GrievanceDataSync { Logger logger = LoggerFactory.getLogger(this.getClass().getName()); RestTemplate restTemplateLogin = new RestTemplate(); @@ -76,9 +76,10 @@ public class GrievanceDataSyncImpl { @Value("${grievanceDataSyncDuration}") private String grievanceDataSyncDuration; - private static String GRIEVANCE_AUTH_TOKEN; - private static Long GRIEVANCE_TOKEN_EXP; + private String GRIEVANCE_AUTH_TOKEN; + private Long GRIEVANCE_TOKEN_EXP; + public List> dataSyncToGrievance(String grievanceAuthorization, String registeringUser, String Authorization) { @@ -124,7 +125,7 @@ public List> dataSyncToGrievance(String grievanceAuthorizati if (response != null && response.hasBody()) { JSONObject obj = new JSONObject(response.getBody()); if (obj != null && obj.has("data") && obj.has("statusCode") && obj.getInt("statusCode") == 200) { - logger.info("Grievance data details response: " + response.getBody()); + logger.info("Grievance data details response received successfully "); String responseStr = response.getBody(); JsonObject jsnOBJ = new JsonObject(); @@ -193,7 +194,7 @@ public List> dataSyncToGrievance(String grievanceAuthorizati grievance.setComplaintId(formattedComplaintId); // Fetch related grievance transaction details - List transactionDetailsList = fetchGrievanceTransactions(formattedComplaintId); + List transactionDetailsList = fetchGrievanceTransactions(grievance.getGrievanceId()); if (transactionDetailsList != null && !transactionDetailsList.isEmpty()) { // Loop through each transaction and set individual properties @@ -315,7 +316,7 @@ public List> dataSyncToGrievance(String grievanceAuthorizati return responseData; } - private List fetchGrievanceTransactions(String complaintId) { + private List fetchGrievanceTransactions(Long grievanceId) { List transactionDetailsList = new ArrayList<>(); try { HttpHeaders headers = new HttpHeaders(); @@ -326,8 +327,12 @@ private List fetchGrievanceTransactions(String complaintId HttpEntity request = new HttpEntity(headers); RestTemplate restTemplate = new RestTemplate(); - ResponseEntity response = restTemplate.exchange(updateGrievanceTransactionDetails, HttpMethod.POST, request, String.class); + // ResponseEntity response = restTemplate.exchange(updateGrievanceTransactionDetails, HttpMethod.POST, request, String.class); + + ResponseEntity response = restTemplate.exchange(updateGrievanceTransactionDetails + grievanceId, HttpMethod.POST, request, String.class); + + if (response != null && response.hasBody()) { JSONObject obj = new JSONObject(response.getBody()); if (obj != null && obj.has("data") && obj.has("statusCode") && obj.getInt("statusCode") == 200) { @@ -340,7 +345,7 @@ private List fetchGrievanceTransactions(String complaintId } } } catch (Exception e) { - logger.error("Error fetching grievance transaction details for complaintId " + complaintId, e); + logger.error("Error fetching grievance transaction details for grievanceId " + grievanceId, e); } return transactionDetailsList; } From ea9ff9e1cd4b1ca5268b8ae09691372f3dad3501 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 04:46:03 -0800 Subject: [PATCH 10/71] adding code rabbit suggestions --- .../com/iemr/common/data/grievance/GrievanceTransaction.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 c6ebcd82..37269a20 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java @@ -228,7 +228,7 @@ public void setStatus(String status) { this.status = status; } - public String comment( ) { + public String getComment( ) { return comment; } From 8825473c48d5728dfb84c1a476c9e1fb4195a1c5 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 04:55:27 -0800 Subject: [PATCH 11/71] code rabbit suggested changes to Model classes --- .../data/grievance/GrievanceDetails.java | 34 ++++++++++--------- .../data/grievance/GrievanceTransaction.java | 6 ++++ 2 files changed, 24 insertions(+), 16 deletions(-) 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 2e26201e..02cdc6ad 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -15,6 +15,7 @@ import jakarta.persistence.Id; import jakarta.persistence.OneToMany; import jakarta.persistence.Table; +import jakarta.validation.constraints.NotBlank; import lombok.Data; @Entity @@ -62,6 +63,7 @@ public class GrievanceDetails { @Expose @Column(name = "Severety") + @NotBlank(message = "Severety is required") private String severety; @Expose @@ -118,17 +120,17 @@ public class GrievanceDetails { @Expose @Column(name = "VanSerialNo") - private Integer VanSerialNo; + private Integer vanSerialNo; @Expose @Column(name = "VanID") - private Integer VanID; + private Integer vanID; @Expose @Column(name = "VehicalNo") - private String VehicalNo; + private String vehicalNo; @Expose @Column(name = "ParkingPlaceID") - private Integer ParkingPlaceID; + private Integer parkingPlaceID; @Expose @Column(name = "SyncedBy") private String syncedBy; @@ -177,10 +179,10 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long this.createdDate = createdDate; this.modifiedBy = modifiedBy; this.lastModDate = lastModDate; - this.VanSerialNo = vanSerialNo; - this.VanID = vanID; - this.VehicalNo = vehicalNo; - this.ParkingPlaceID = parkingPlaceID; + this.vanSerialNo = vanSerialNo; + this.vanID = vanID; + this.vehicalNo = vehicalNo; + this.parkingPlaceID = parkingPlaceID; this.syncedBy = syncedBy; this.syncedDate = syncedDate; this.isCompleted = isCompleted; @@ -372,35 +374,35 @@ public void setLastModDate(Timestamp lastModDate) { } public Integer getVanSerialNo() { - return VanSerialNo; + return vanSerialNo; } public void setVanSerialNo(Integer vanSerialNo) { - this.VanSerialNo = vanSerialNo; + this.vanSerialNo = vanSerialNo; } public Integer getVanId() { - return VanID; + return vanID; } public void setVanId(Integer vanId) { - this.VanID = vanId; + this.vanID = vanId; } public String getVehicleNo() { - return VehicalNo; + return vehicalNo; } public void setVehicleNo(String vehicleNo) { - this.VehicalNo = vehicleNo; + this.vehicalNo = vehicleNo; } public Integer getParkingPlaceId() { - return ParkingPlaceID; + return parkingPlaceID; } public void setParkingPlaceId(Integer parkingPlaceId) { - this.ParkingPlaceID = parkingPlaceId; + this.parkingPlaceID = parkingPlaceId; } public String getSyncedBy() { 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 37269a20..b559339f 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java @@ -5,6 +5,8 @@ import com.google.gson.annotations.Expose; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; import lombok.Data; import java.util.Date; @@ -25,10 +27,14 @@ public class GrievanceTransaction { @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; @Column(name = "Redressed", nullable = false) From 2d639c4fcaa2a9c42c48238b0ce8e0864170074a Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 06:01:13 -0800 Subject: [PATCH 12/71] adding sonar quality changes --- .../common/config/quartz/QuartzConfig.java | 2 +- .../quartz/ScheduleForGrievanceDataSync.java | 11 ++- .../data/grievance/GrievanceDetails.java | 8 +- .../GrievanceFetchBenDetailsRepo.java | 2 + .../service/grievance/GrievanceDataSync.java | 3 +- .../grievance/GrievanceDataSyncImpl.java | 79 ++++++------------- 6 files changed, 40 insertions(+), 65 deletions(-) diff --git a/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java b/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java index 468e9a4b..ac359f40 100644 --- a/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java +++ b/src/main/java/com/iemr/common/config/quartz/QuartzConfig.java @@ -170,7 +170,7 @@ public CronTriggerFactoryBean processMQTriggerForEmail() { Boolean startJob = ConfigProperties.getBoolean("start-email-scheduler"); CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean(); String scheduleConfig = quartzJobDefaultSchedule; - if (startJob) { + if (Boolean.TRUE.equals(startJob)) { scheduleConfig = ConfigProperties.getPropertyByName("cron-scheduler-email"); } cronTriggerFactoryBean.setJobDetail(processMQJobForEmail().getObject()); diff --git a/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java b/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java index f1d5a7dd..e4eedf01 100644 --- a/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java +++ b/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java @@ -17,15 +17,20 @@ public class ScheduleForGrievanceDataSync implements Job { private final Logger logger = LoggerFactory.getLogger(this.getClass().getName()); + + private final GrievanceDataSync grievanceDataSync; + @Autowired - GrievanceDataSync grievanceDataSync; + public ScheduleForGrievanceDataSync(GrievanceDataSync grievanceDataSync) { + this.grievanceDataSync = grievanceDataSync; + } @Override public void execute(JobExecutionContext arg0) throws JobExecutionException { - logger.info("Started job for grievance data sync " + arg0.getClass().getName()); + logger.info("Started job for grievance data sync " , arg0.getClass().getName()); grievanceDataSync.dataSyncToGrievance(); - logger.info("Completed job for grievance data sync " + arg0.getClass().getName()); + logger.info("Completed job for grievance data sync " , arg0.getClass().getName()); } 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 02cdc6ad..160d0d83 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -102,7 +102,7 @@ public class GrievanceDetails { @Expose @Column(name = "Processed") - private Character Processed = 'N'; + private Character processed = 'N'; @Column(name = "CreatedBy") @Expose @@ -174,7 +174,7 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long this.isRegistered = isRegistered; this.callCounter = callCounter; this.deleted = deleted; - this.Processed = processed; + this.processed = processed; this.createdBy = createdBy; this.createdDate = createdDate; this.modifiedBy = modifiedBy; @@ -334,11 +334,11 @@ public void setDeleted(Boolean deleted) { } public Character getProcessed() { - return Processed; + return processed; } public void setProcessed(Character processed) { - this.Processed = processed; + this.processed = processed; } public String getCreatedBy() { 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 19b470f8..1a2a91d6 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java @@ -1,6 +1,8 @@ package com.iemr.common.repository.grievance; + import java.util.ArrayList; +import java.util.List; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.CrudRepository; 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 9f98da4c..188e1cb5 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -4,6 +4,5 @@ import java.util.Map; public interface GrievanceDataSync { - public List> dataSyncToGrievance(String grievanceAuthorization, String registeringUser, - String Authorization); + public List> dataSyncToGrievance(); } 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 ba7b2733..f12ddda5 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -46,17 +46,22 @@ public class GrievanceDataSyncImpl implements GrievanceDataSync { RestTemplate restTemplateLogin = new RestTemplate(); - @Autowired - private GrievanceDataRepo grievanceDataRepo; - - @Autowired - private GrievanceTransactionRepo grievanceTransactionRepo; - - @Autowired - private GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo; + private final GrievanceDataRepo grievanceDataRepo; + private final GrievanceTransactionRepo grievanceTransactionRepo; + private final GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo; + private final LocationStateRepository locationStateRepository; + // Constructor-based injection @Autowired - private LocationStateRepository locationStateRepository; + public GrievanceDataSyncImpl(GrievanceDataRepo grievanceDataRepo, + GrievanceTransactionRepo grievanceTransactionRepo, + GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo, + LocationStateRepository locationStateRepository) { + this.grievanceDataRepo = grievanceDataRepo; + this.grievanceTransactionRepo = grievanceTransactionRepo; + this.grievanceFetchBenDetailsRepo = grievanceFetchBenDetailsRepo; + this.locationStateRepository = locationStateRepository; + } @Value("${greivanceUserAuthenticate}") private String grievanceUserAuthenticate; @@ -80,10 +85,13 @@ public class GrievanceDataSyncImpl implements GrievanceDataSync { private Long GRIEVANCE_TOKEN_EXP; - public List> dataSyncToGrievance(String grievanceAuthorization, String registeringUser, - String Authorization) { +// public List> dataSyncToGrievance(String grievanceAuthorization, String registeringUser, +// String Authorization) { + public List> dataSyncToGrievance() { + int count = 0; + String registeringUser = ""; List> responseData = new ArrayList<>(); List grievanceDetailsListAS = null; try { @@ -134,49 +142,12 @@ public List> dataSyncToGrievance(String grievanceAuthorizati jsnOBJ = jsnElmnt.getAsJsonObject(); JsonObject grievanceJsonData = jsnOBJ.getAsJsonObject("data"); + 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); - // Fetch transaction details and integrate them with the grievance details -// for (GrievanceDetails grievance : grievanceDetailsList) { -// String complaintId = grievance.getGrievanceId(); -// String formattedComplaintId = complaintId.replace("\\/", "/"); -// grievance.setGrievanceId(formattedComplaintId); -// -// // Fetch related grievance transaction details -// List transactionDetailsList = fetchGrievanceTransactions(formattedComplaintId); -// -// if (transactionDetailsList != null && !transactionDetailsList.isEmpty()) { -// // Save transactions to the t_grievance_transaction table -// grievanceTransactionRepo.saveAll(transactionDetailsList); -// // Add the transaction list to the grievance object -// grievance.setGrievanceTransactionDetails(transactionDetailsList); -// } -// -// // Adding other grievance-related fields -// grievance.setSubjectOfComplaint(grievanceJsonData.get("subject").getAsString()); -// ArrayList lists = grievanceFetchBenDetailsRepo.findByComplaintId(formattedComplaintId); -// -// 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.setProviderServiceMapId((Integer) objects[3]); -// String state = locationStateRepository.findByStateIDForGrievance((Integer) objects[4]); -// grievance.setState(state); -// } -// } -// -// grievance.setAgentId(grievance.getAgentId()); -// grievance.setDeleted(grievance.getDeleted()); -// grievance.setCreatedBy(registeringUser); -// grievance.setProcessed('N'); -// grievance.setIsAllocated(false); -// grievance.setCallCounter(0); -// grievance.setRetryNeeded(true); -// } ////////////////////// // Loop through the fetched grievance list and integrate transaction details @@ -327,7 +298,6 @@ private List fetchGrievanceTransactions(Long grievanceId) HttpEntity request = new HttpEntity(headers); RestTemplate restTemplate = new RestTemplate(); - // ResponseEntity response = restTemplate.exchange(updateGrievanceTransactionDetails, HttpMethod.POST, request, String.class); ResponseEntity response = restTemplate.exchange(updateGrievanceTransactionDetails + grievanceId, HttpMethod.POST, request, String.class); @@ -351,7 +321,7 @@ private List fetchGrievanceTransactions(Long grievanceId) } private void generateGrievanceAuthToken() { - String Authorization = ""; + String authorization = ""; String registeringUser = ""; MultiValueMap requestData = new LinkedMultiValueMap(); requestData.add("username", grievanceUserName); @@ -377,7 +347,7 @@ private void generateGrievanceAuthToken() { + jsnOBJ.get("access_token").getAsString(); JsonObject grievanceLoginJsonData = jsnOBJ.getAsJsonObject("data"); - Authorization = grievanceLoginJsonData.get("key").getAsString(); + authorization = grievanceLoginJsonData.get("key").getAsString(); registeringUser = grievanceLoginJsonData.get("userName").getAsString(); logger.info("Auth key generated at : " + System.currentTimeMillis() + ", Key : " + GRIEVANCE_AUTH_TOKEN); @@ -393,8 +363,7 @@ private void generateGrievanceAuthToken() { int count = 3; while (count > 0) { - List> savedGrievanceData = dataSyncToGrievance(GRIEVANCE_AUTH_TOKEN, registeringUser, - Authorization); + List> savedGrievanceData = dataSyncToGrievance(); if (savedGrievanceData != null) break; else From b0e039b57467606e030d18e0e3cf88de8b42e3da Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 06:47:00 -0800 Subject: [PATCH 13/71] adding sonar quality code suggestions --- .../quartz/ScheduleForGrievanceDataSync.java | 4 ++-- .../GrievanceFetchBenDetailsRepo.java | 1 - .../grievance/GrievanceDataSyncImpl.java | 24 +++++++------------ 3 files changed, 11 insertions(+), 18 deletions(-) diff --git a/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java b/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java index e4eedf01..8843738c 100644 --- a/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java +++ b/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java @@ -28,9 +28,9 @@ public ScheduleForGrievanceDataSync(GrievanceDataSync grievanceDataSync) { @Override public void execute(JobExecutionContext arg0) throws JobExecutionException { - logger.info("Started job for grievance data sync " , arg0.getClass().getName()); + logger.info("Started job for grievance data sync {}", arg0.getClass().getName()); grievanceDataSync.dataSyncToGrievance(); - logger.info("Completed job for grievance data sync " , arg0.getClass().getName()); + logger.info("Completed job for grievance data sync {}" , arg0.getClass().getName()); } 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 1a2a91d6..2d8c6c41 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java @@ -2,7 +2,6 @@ import java.util.ArrayList; -import java.util.List; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.CrudRepository; 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 f12ddda5..0053917b 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -46,6 +46,10 @@ public class GrievanceDataSyncImpl implements GrievanceDataSync { RestTemplate restTemplateLogin = new RestTemplate(); + private static final String USER_AGENT_HEADER = "user-agent"; + private static final String USER_AGENT_VALUE = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"; + private static final String STATUS_CODE = "statusCode"; + private final GrievanceDataRepo grievanceDataRepo; private final GrievanceTransactionRepo grievanceTransactionRepo; private final GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo; @@ -85,9 +89,6 @@ public GrievanceDataSyncImpl(GrievanceDataRepo grievanceDataRepo, private Long GRIEVANCE_TOKEN_EXP; -// public List> dataSyncToGrievance(String grievanceAuthorization, String registeringUser, -// String Authorization) { - public List> dataSyncToGrievance() { int count = 0; @@ -109,19 +110,14 @@ public List> dataSyncToGrievance() { HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); - headers.add("user-agent", - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"); + headers.add(USER_AGENT_HEADER, USER_AGENT_VALUE); headers.add("AUTHORIZATION", GRIEVANCE_AUTH_TOKEN); Date date = new Date(); java.sql.Date sqlDate = new java.sql.Date(date.getTime()); - String text = sqlDate.toString(); - Timestamp currentDate = new Timestamp(sqlDate.getTime()); Calendar calendar = Calendar.getInstance(); calendar.setTime(sqlDate); calendar.add(Calendar.DATE, -Integer.parseInt(grievanceDataSyncDuration)); - Date beforeDate = calendar.getTime(); - Timestamp lastDate = new Timestamp(beforeDate.getTime()); // Request object HttpEntity request = new HttpEntity(headers); @@ -132,7 +128,7 @@ public List> dataSyncToGrievance() { if (response != null && response.hasBody()) { JSONObject obj = new JSONObject(response.getBody()); - if (obj != null && obj.has("data") && obj.has("statusCode") && obj.getInt("statusCode") == 200) { + if (obj != null && obj.has("data") && obj.has(STATUS_CODE) && obj.getInt(STATUS_CODE) == 200) { logger.info("Grievance data details response received successfully "); String responseStr = response.getBody(); @@ -292,8 +288,7 @@ private List fetchGrievanceTransactions(Long grievanceId) try { HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); - headers.add("user-agent", - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"); + headers.add(USER_AGENT_HEADER, USER_AGENT_VALUE); headers.add("AUTHORIZATION", GRIEVANCE_AUTH_TOKEN); HttpEntity request = new HttpEntity(headers); @@ -305,7 +300,7 @@ private List fetchGrievanceTransactions(Long grievanceId) if (response != null && response.hasBody()) { JSONObject obj = new JSONObject(response.getBody()); - if (obj != null && obj.has("data") && obj.has("statusCode") && obj.getInt("statusCode") == 200) { + if (obj != null && obj.has("data") && obj.has(STATUS_CODE) && obj.getInt(STATUS_CODE) == 200) { JsonObject jsnOBJ = new JsonObject(); JsonParser jsnParser = new JsonParser(); JsonElement jsnElmnt = jsnParser.parse(response.getBody()); @@ -329,8 +324,7 @@ private void generateGrievanceAuthToken() { requestData.add("grant_type", "password"); HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED); - httpHeaders.add("user-agent", - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"); + httpHeaders.add(USER_AGENT_HEADER, USER_AGENT_VALUE); HttpEntity> httpRequestEntity = new HttpEntity>( requestData, httpHeaders); From 9831500c2df43daf24ed10fb1735be92993392e8 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 18:53:58 -0800 Subject: [PATCH 14/71] adding sonar quality check suggestions --- .../grievance/GrievanceDataSyncImpl.java | 21 ++++++------------- 1 file changed, 6 insertions(+), 15 deletions(-) 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 0053917b..46856403 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -171,7 +171,6 @@ public List> dataSyncToGrievance() { JsonObject transactionDetailsJson = grievanceJsonData.getAsJsonObject("transactionDetails"); // or another relevant path // Adding properties for each transaction detail - // transactionDetails.setComplaintId(formattedComplaintId); // Assuming these fields are coming from your API response transactionDetails.setActionTakenBy(transactionDetailsJson.get("actionTakenBy").getAsString()); transactionDetails.setStatus(transactionDetailsJson.get("status").getAsString()); @@ -227,8 +226,7 @@ public List> dataSyncToGrievance() { combinedData.put("complaint", grievance.getComplaint()); combinedData.put("beneficiaryRegID", grievance.getBeneficiaryRegId()); combinedData.put("providerServiceMapId", grievance.getProviderServiceMapId()); - // combinedData.put("firstName", grievance.getFirstName()); - // combinedData.put("lastName", grievance.getLastName()); + combinedData.put("primaryNumber", grievance.getPrimaryNumber()); // Add transaction data @@ -255,23 +253,18 @@ public List> dataSyncToGrievance() { combinedData.put("createdDate", grievance.getCreatedDate()); combinedData.put("lastModDate", grievance.getLastModDate()); combinedData.put("isCompleted", grievance.getIsCompleted()); - // combinedData.put("gender", grievance.getGender()); - // combinedData.put("district", grievance.getDistrict()); - // combinedData.put("beneficiaryID", grievance.getBeneficiaryId()); - // combinedData.put("age", grievance.getAge()); + combinedData.put("retryNeeded", grievance.getRetryNeeded()); combinedData.put("callCounter", grievance.getCallCounter()); - // combinedData.put("lastCall", grievance.getLastCall()); responseData.add(combinedData); } // Return the combined response as required - // return responseData; } else { - logger.info("No records found for page = " + count); + logger.info("No records found for page = {}" , count); count = -1; } } @@ -316,8 +309,7 @@ private List fetchGrievanceTransactions(Long grievanceId) } private void generateGrievanceAuthToken() { - String authorization = ""; - String registeringUser = ""; + MultiValueMap requestData = new LinkedMultiValueMap(); requestData.add("username", grievanceUserName); requestData.add("password", grievancePassword); @@ -341,10 +333,9 @@ private void generateGrievanceAuthToken() { + jsnOBJ.get("access_token").getAsString(); JsonObject grievanceLoginJsonData = jsnOBJ.getAsJsonObject("data"); - authorization = grievanceLoginJsonData.get("key").getAsString(); - registeringUser = grievanceLoginJsonData.get("userName").getAsString(); + - logger.info("Auth key generated at : " + System.currentTimeMillis() + ", Key : " + GRIEVANCE_AUTH_TOKEN); + logger.info("Auth key generated at : {}" , System.currentTimeMillis() + ", Key : {}" , GRIEVANCE_AUTH_TOKEN); Date date = new Date(); java.sql.Date sqlDate = new java.sql.Date(date.getTime()); From 5cb688601200446c63fd293a0b46c6f03e5b5e9f Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 19:08:58 -0800 Subject: [PATCH 15/71] adding code rabbit suggestions --- .../service/grievance/GrievanceDataSyncImpl.java | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) 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 46856403..49a6dd33 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -348,14 +348,24 @@ private void generateGrievanceAuthToken() { int count = 3; while (count > 0) { + try { List> savedGrievanceData = dataSyncToGrievance(); if (savedGrievanceData != null) break; - else + else { count--; + + if (count > 0) { + Thread.sleep(5000); + } + } + + } catch(InterruptedException e) { + Thread.currentThread().interrupt(); + break; } } } } - +} From 9e8e1f271d65af13a8d4757cd079efdde3865410 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 16 Jan 2025 19:19:06 -0800 Subject: [PATCH 16/71] adding constant instead of duplicate literals --- .../service/grievance/GrievanceDataSyncImpl.java | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) 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 49a6dd33..c13a92a0 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -50,6 +50,10 @@ public class GrievanceDataSyncImpl implements GrievanceDataSync { private static final String USER_AGENT_VALUE = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"; private static final String STATUS_CODE = "statusCode"; + private static final String FILE_NAME = "fileName"; + private static final String FILE_TYPE = "fileType"; + + private final GrievanceDataRepo grievanceDataRepo; private final GrievanceTransactionRepo grievanceTransactionRepo; private final GrievanceFetchBenDetailsRepo grievanceFetchBenDetailsRepo; @@ -174,8 +178,8 @@ public List> dataSyncToGrievance() { // 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("fileName") ? transactionDetailsJson.get("fileName").getAsString() : null); - transactionDetails.setFileType(transactionDetailsJson.has("fileType") ? transactionDetailsJson.get("fileType").getAsString() : null); + 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())); @@ -235,8 +239,8 @@ public List> dataSyncToGrievance() { Map transactionData = new HashMap<>(); transactionData.put("actionTakenBy", transaction.getActionTakenBy()); transactionData.put("status", transaction.getStatus()); - transactionData.put("fileName", transaction.getFileName()); - transactionData.put("fileType", transaction.getFileType()); + 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()); From 7b3b9907d10c2e311a28b0cdf59938f6df9a0202 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Sun, 19 Jan 2025 07:27:14 -0800 Subject: [PATCH 17/71] adding cod changs to fetch unallocated grievance count --- .../grievance/GrievanceController.java | 42 +++++++++++++++++++ .../grievance/GrievanceDataRepo.java | 7 ++-- .../service/grievance/GrievanceDataSync.java | 7 ++++ .../grievance/GrievanceDataSyncImpl.java | 19 ++++++++- 4 files changed, 69 insertions(+), 6 deletions(-) create mode 100644 src/main/java/com/iemr/common/controller/grievance/GrievanceController.java diff --git a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java new file mode 100644 index 00000000..43d38d00 --- /dev/null +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -0,0 +1,42 @@ +package com.iemr.common.controller.grievance; + + +import com.iemr.common.service.grievance.GrievanceDataSync; +import com.iemr.common.utils.response.OutputResponse; + +import io.swagger.v3.oas.annotations.Operation; + + +import javax.ws.rs.core.MediaType; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RestController; + +@RestController +public class GrievanceController { + final Logger logger = LoggerFactory.getLogger(this.getClass().getName()); + + @Autowired + private GrievanceDataSync grievanceDataSync; + + + @CrossOrigin() + @Operation(summary = "/unallocatedGrievanceCount") + @RequestMapping(value = "/unallocatedGrievanceCount", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + public String fetchUnallocatedGrievanceCount() { + OutputResponse responseData = new OutputResponse(); + try { + responseData.setResponse(grievanceDataSync.fetchUnallocatedGrievanceCount()); + } catch (Exception e) { + logger.error("UnallocatedGrievanceCount failed with error" + e.getMessage(), e); + responseData.setError(e); + } + return responseData.toString(); + + } +} 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 a428c743..13457a96 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -7,9 +7,6 @@ import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; - - - import com.iemr.common.data.grievance.GrievanceDetails; @Repository @@ -18,6 +15,8 @@ public interface GrievanceDataRepo extends CrudRepository 0 FROM GrievanceDetails g WHERE g.complaintId = :complaintId") boolean existsByComplaintId(@Param("complaintId") String complaintId); - + @Query("select count(request) " + + "from GrievanceDetails request where request.isAllocated = false") + public Long fetchUnallocatedGrievanceCount(); } 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 188e1cb5..ec0992f7 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -3,6 +3,13 @@ import java.util.List; import java.util.Map; +import org.json.JSONException; + +import com.iemr.common.utils.exception.IEMRException; + public interface GrievanceDataSync { public List> dataSyncToGrievance(); + + public String fetchUnallocatedGrievanceCount() throws IEMRException, JSONException; + } 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 c13a92a0..1b687ce7 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -11,7 +11,8 @@ import java.util.List; import java.util.Map; - import org.json.JSONObject; +import org.json.JSONException; +import org.json.JSONObject; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; @@ -37,7 +38,8 @@ import com.iemr.common.repository.grievance.GrievanceFetchBenDetailsRepo; import com.iemr.common.repository.grievance.GrievanceTransactionRepo; import com.iemr.common.repository.location.LocationStateRepository; - import com.iemr.common.utils.mapper.InputMapper; +import com.iemr.common.utils.exception.IEMRException; +import com.iemr.common.utils.mapper.InputMapper; @Service @PropertySource("classpath:application.properties") @@ -371,5 +373,18 @@ private void generateGrievanceAuthToken() { } } } + + public String fetchUnallocatedGrievanceCount() throws IEMRException, JSONException { + logger.debug("Request received for fetchUnallocatedGrievanceCount"); + + Long unallocatedCount = grievanceDataRepo.fetchUnallocatedGrievanceCount(); + + // Create a response JSON object + JSONObject result = new JSONObject(); + result.put("count", unallocatedCount); // Store the count of unallocated grievances + + // Return the result as a string + return result.toString(); + } } From d834aa9b3dacccd29fc507c5eb785c5b38185d9e Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 20 Jan 2025 05:13:49 -0800 Subject: [PATCH 18/71] adding changes suggested by sonar quality check --- .../common/controller/grievance/GrievanceController.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) 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 43d38d00..599e9caa 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -13,6 +13,7 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; @@ -21,13 +22,17 @@ public class GrievanceController { final Logger logger = LoggerFactory.getLogger(this.getClass().getName()); - @Autowired + private GrievanceDataSync grievanceDataSync; + @Autowired + public GrievanceController(GrievanceDataSync grievanceDataSync) { + this.grievanceDataSync = grievanceDataSync; + } @CrossOrigin() @Operation(summary = "/unallocatedGrievanceCount") - @RequestMapping(value = "/unallocatedGrievanceCount", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + @PostMapping(value = "/unallocatedGrievanceCount", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") public String fetchUnallocatedGrievanceCount() { OutputResponse responseData = new OutputResponse(); try { From 734551aa2ef836169b209ca5c93d95370a0b33c2 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 20 Jan 2025 05:38:46 -0800 Subject: [PATCH 19/71] adding code rabbit suggested changes --- .../controller/grievance/GrievanceController.java | 15 ++++++++++++--- .../service/grievance/GrievanceDataSyncImpl.java | 11 ++++++----- 2 files changed, 18 insertions(+), 8 deletions(-) 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 599e9caa..563334e4 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -2,6 +2,7 @@ import com.iemr.common.service.grievance.GrievanceDataSync; +import com.iemr.common.utils.exception.IEMRException; import com.iemr.common.utils.response.OutputResponse; import io.swagger.v3.oas.annotations.Operation; @@ -9,13 +10,12 @@ import javax.ws.rs.core.MediaType; +import org.json.JSONException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.PostMapping; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; @RestController @@ -37,7 +37,16 @@ public String fetchUnallocatedGrievanceCount() { OutputResponse responseData = new OutputResponse(); try { responseData.setResponse(grievanceDataSync.fetchUnallocatedGrievanceCount()); - } catch (Exception e) { + } + catch (IEMRException e) { + logger.error("Business logic error in UnallocatedGrievanceCount" + e.getMessage(), e); + responseData.setError(e); + } + catch (JSONException e) { + logger.error("JSON processing error in UnallocatedGrievanceCount" + e.getMessage(), e); + responseData.setError(e); + } + catch (Exception e) { logger.error("UnallocatedGrievanceCount failed with error" + e.getMessage(), e); responseData.setError(e); } 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 1b687ce7..c9e421e6 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -378,12 +378,13 @@ public String fetchUnallocatedGrievanceCount() throws IEMRException, JSONExcepti logger.debug("Request received for fetchUnallocatedGrievanceCount"); Long unallocatedCount = grievanceDataRepo.fetchUnallocatedGrievanceCount(); - - // Create a response JSON object - JSONObject result = new JSONObject(); - result.put("count", unallocatedCount); // Store the count of unallocated grievances - // Return the result as a string + if (unallocatedCount == null) { + throw new IEMRException("Failed to fetch unallocated grievance count"); + } + + JSONObject result = new JSONObject(); + result.put("count", unallocatedCount); return result.toString(); } From 47ceb56ac2ecc5df42afc002392318e7685162e3 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 21 Jan 2025 02:13:06 -0800 Subject: [PATCH 20/71] fixing config file --- src/main/java/com/iemr/common/config/PrimaryDBConfig.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java index da5268b3..fc1eeb8f 100644 --- a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java +++ b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java @@ -47,7 +47,7 @@ @Configuration @EnableTransactionManagement @EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactory", basePackages = { "com.iemr.common.repository", - "com.iemr.common.repo", "com.iemr.common.notification.agent", "com.iemr.common.covidVaccination", "com.iemr.common.repository.everwell.*", " com.iemr.common.repository.users" }) + "com.iemr.common.repo", "com.iemr.common.notification.agent", "com.iemr.common.covidVaccination", "com.iemr.common.repository.everwell.*", "com.iemr.common.data.grievance"," com.iemr.common.repository.users" }) public class PrimaryDBConfig { Logger logger = LoggerFactory.getLogger(this.getClass().getName()); From f26b8ff9b5a1c6762ceb7772c4a04499694a2556 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 21 Jan 2025 02:24:18 -0800 Subject: [PATCH 21/71] fixing space --- src/main/java/com/iemr/common/config/PrimaryDBConfig.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java index fc1eeb8f..1523fb96 100644 --- a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java +++ b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java @@ -47,7 +47,7 @@ @Configuration @EnableTransactionManagement @EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactory", basePackages = { "com.iemr.common.repository", - "com.iemr.common.repo", "com.iemr.common.notification.agent", "com.iemr.common.covidVaccination", "com.iemr.common.repository.everwell.*", "com.iemr.common.data.grievance"," com.iemr.common.repository.users" }) + "com.iemr.common.repo", "com.iemr.common.notification.agent", "com.iemr.common.covidVaccination", "com.iemr.common.repository.everwell.*", "com.iemr.common.data.grievance", " com.iemr.common.repository.users" }) public class PrimaryDBConfig { Logger logger = LoggerFactory.getLogger(this.getClass().getName()); From d3534d9f19d5266f241022ff8dfd891129d2c686 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 21 Jan 2025 02:25:31 -0800 Subject: [PATCH 22/71] fixing space issue --- src/main/java/com/iemr/common/config/PrimaryDBConfig.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java index 1523fb96..63042b1e 100644 --- a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java +++ b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java @@ -47,7 +47,7 @@ @Configuration @EnableTransactionManagement @EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactory", basePackages = { "com.iemr.common.repository", - "com.iemr.common.repo", "com.iemr.common.notification.agent", "com.iemr.common.covidVaccination", "com.iemr.common.repository.everwell.*", "com.iemr.common.data.grievance", " com.iemr.common.repository.users" }) + "com.iemr.common.repo", "com.iemr.common.notification.agent", "com.iemr.common.covidVaccination", "com.iemr.common.repository.everwell.*", "com.iemr.common.data.grievance", "com.iemr.common.repository.users" }) public class PrimaryDBConfig { Logger logger = LoggerFactory.getLogger(this.getClass().getName()); From 6b58965d1b6f1abcb7131aacb1ab62c99c1dfa84 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 21 Jan 2025 21:18:10 -0800 Subject: [PATCH 23/71] adding package for PrimaryDBConfig --- src/main/java/com/iemr/common/config/PrimaryDBConfig.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java index 63042b1e..36463ab9 100644 --- a/src/main/java/com/iemr/common/config/PrimaryDBConfig.java +++ b/src/main/java/com/iemr/common/config/PrimaryDBConfig.java @@ -83,7 +83,7 @@ public DataSource dataSource() { public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder, @Qualifier("dataSource") DataSource dataSource) { return builder.dataSource(dataSource).packages("com.iemr.common.data", "com.iemr.common.notification", - "com.iemr.common.model", "com.iemr.common.covidVaccination", "com.iemr.common.data.everwell", "com.iemr.common.data.users").persistenceUnit("db_iemr").build(); + "com.iemr.common.model", "com.iemr.common.covidVaccination", "com.iemr.common.data.everwell", "com.iemr.common.data.grievance", "com.iemr.common.data.users").persistenceUnit("db_iemr").build(); } @Primary From b5798d2a9ab964053405831c40f111d836dca5cb Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Wed, 22 Jan 2025 00:24:32 -0800 Subject: [PATCH 24/71] adding code changes for allocate API for allocating grievance to agents --- .../grievance/GrievanceController.java | 36 ++++++++- .../grievance/GrievanceAllocationRequest.java | 68 ++++++++++++++++ .../grievance/GrievanceDataRepo.java | 20 +++++ .../grievance/GrievanceHandlingService.java | 9 +++ .../GrievanceHandlingServiceImpl.java | 81 +++++++++++++++++++ 5 files changed, 211 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/iemr/common/data/grievance/GrievanceAllocationRequest.java create mode 100644 src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java create mode 100644 src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java 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 563334e4..c4f04b7a 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -2,12 +2,12 @@ import com.iemr.common.service.grievance.GrievanceDataSync; +import com.iemr.common.service.grievance.GrievanceHandlingService; import com.iemr.common.utils.exception.IEMRException; import com.iemr.common.utils.response.OutputResponse; +import io.lettuce.core.dynamic.annotation.Param; import io.swagger.v3.oas.annotations.Operation; - - import javax.ws.rs.core.MediaType; import org.json.JSONException; @@ -16,6 +16,9 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; @RestController @@ -24,11 +27,15 @@ public class GrievanceController { private GrievanceDataSync grievanceDataSync; + + private final GrievanceHandlingService grievanceHandlingService; @Autowired - public GrievanceController(GrievanceDataSync grievanceDataSync) { + public GrievanceController(GrievanceHandlingService grievanceHandlingService, GrievanceDataSync grievanceDataSync) { this.grievanceDataSync = grievanceDataSync; + this.grievanceHandlingService = grievanceHandlingService; } + @CrossOrigin() @Operation(summary = "/unallocatedGrievanceCount") @@ -53,4 +60,27 @@ public String fetchUnallocatedGrievanceCount() { return responseData.toString(); } + + + + @Operation(summary = "Allocate grievances to users") + @RequestMapping(value = "/allocateGrievances", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + public String allocateGrievances(@Param(value = "{\"startDate\":\"ISO-8601 format start date (e.g., 2022-12-01T07:49:00.000Z)\", " + + "\"endDate\":\"ISO-8601 format end date (e.g., 2025-01-16T07:49:30.561)\", " + + "\"userID\":\"Array list of User IDs (agents to be allocated grievances)\", " + + "\"allocateNo\":\"Integer - number of grievances to be allocated to each user\"," + + "\"language\":\"String - language to filter grievances by\"}") + + @RequestBody String request) { + OutputResponse response = new OutputResponse(); + try { + // Call the service to allocate grievances based on the incoming JSON request + response.setResponse(grievanceHandlingService.allocateGrievances(request)); + } catch (Exception e) { + logger.error("Grievance allocation 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 new file mode 100644 index 00000000..7bf44e44 --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceAllocationRequest.java @@ -0,0 +1,68 @@ +package com.iemr.common.data.grievance; + + + import java.time.LocalDateTime; + import java.util.List; + + public class GrievanceAllocationRequest { + + private LocalDateTime startDate; // Start date for filtering grievances + private LocalDateTime endDate; // End date for filtering grievances + private List userID; // 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 language; + // Getters and Setters + + public LocalDateTime getStartDate() { + return startDate; + } + + public void setStartDate(LocalDateTime startDate) { + this.startDate = startDate; + } + + public LocalDateTime getEndDate() { + return endDate; + } + + public void setEndDate(LocalDateTime endDate) { + this.endDate = endDate; + } + + public List getUserID() { + return userID; + } + + public void setUserID(List userID) { + this.userID = userID; + } + + public Integer getAllocateNo() { + return allocateNo; + } + + public void setAllocateNo(Integer allocateNo) { + this.allocateNo = allocateNo; + } + + public String getLanguage() { + return language; + } + + public void setLanguage(String language) { + this.language = language; + } + + @Override + public String toString() { + return "GrievanceAllocationRequest{" + + "startDate=" + startDate + + ", endDate=" + endDate + + ", userID=" + userID + + ", allocateNo=" + allocateNo + + ", language=" + language + + '}'; + } + + +} 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 13457a96..4ee6e7f7 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -3,12 +3,18 @@ +import java.time.LocalDateTime; +import java.util.List; + +import org.springframework.data.jpa.repository.Modifying; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.CrudRepository; 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 GrievanceDataRepo extends CrudRepository{ @@ -19,4 +25,18 @@ public interface GrievanceDataRepo extends CrudRepository findGrievancesInDateRangeAndLanguage( + @Param("startDate") LocalDateTime startDate, + @Param("endDate") LocalDateTime endDate, + @Param("language") String language); + + + @Modifying + @Query("UPDATE Grievance g SET g.isAllocated = true, g.userId = :userId WHERE g.id = :grievanceId") + @Transactional + public int allocateGrievance(@Param("grievanceId") Long grievanceId, @Param("userId") Integer userId); + + } diff --git a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java new file mode 100644 index 00000000..19a96723 --- /dev/null +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java @@ -0,0 +1,9 @@ +package com.iemr.common.service.grievance; + +import org.springframework.stereotype.Service; + +@Service +public interface GrievanceHandlingService { + public String allocateGrievances(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 new file mode 100644 index 00000000..74f3af8c --- /dev/null +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -0,0 +1,81 @@ +package com.iemr.common.service.grievance; + +import java.util.Comparator; +import java.util.List; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.PropertySource; +import org.springframework.stereotype.Service; + +import com.iemr.common.data.grievance.GrievanceAllocationRequest; +import com.iemr.common.data.grievance.GrievanceDetails; +import com.iemr.common.repository.grievance.GrievanceDataRepo; +import com.iemr.common.utils.mapper.InputMapper; + +@Service +@PropertySource("classpath:application.properties") +public class GrievanceHandlingServiceImpl implements GrievanceHandlingService { + + + private Logger logger = LoggerFactory.getLogger(GrievanceHandlingService.class); + + @Autowired + private GrievanceDataRepo grievanceDataRepo; // Repository for grievance-related database operations + + @Value("${grievanceAllocationRetryConfiguration}") + private int grievanceAllocationRetryConfiguration; // Value from application.properties, can be used to configure 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 2: Fetch grievances based on the start date, end date range, and language + List grievances = grievanceDataRepo.findGrievancesInDateRangeAndLanguage( + allocationRequest.getStartDate(), allocationRequest.getEndDate(), 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 + + // Step 5: Allocate grievances to users in a round-robin fashion + for (int i = 0; i < grievances.size(); i++) { + if (i % allocateNo == 0 && userIndex < userIds.size()) { + // Allocate to the next user when reaching the allocateNo threshold + Integer userId = userIds.get(userIndex); + GrievanceDetails grievance = grievances.get(i); + + // Call the repository method to allocate the grievance to the user + int rowsAffected = grievanceDataRepo.allocateGrievance(grievance.getGrievanceId(), userId); + + if (rowsAffected > 0) { + totalAllocated++; + logger.debug("Allocated grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); + } else { + logger.error("Failed to allocate grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); + } + + userIndex = (userIndex + 1) % userIds.size(); + } + } + + // Step 6: Return a message with the total number of grievances allocated + return "Successfully allocated " + totalAllocated + " grievances to users."; + } + + +} From abe5bd306a6786244f54b26cbc12218c6fbdf9f9 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Wed, 22 Jan 2025 00:24:57 -0800 Subject: [PATCH 25/71] removing space --- .../iemr/common/controller/grievance/GrievanceController.java | 1 - 1 file changed, 1 deletion(-) 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 c4f04b7a..bb75417a 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -5,7 +5,6 @@ import com.iemr.common.service.grievance.GrievanceHandlingService; import com.iemr.common.utils.exception.IEMRException; import com.iemr.common.utils.response.OutputResponse; - import io.lettuce.core.dynamic.annotation.Param; import io.swagger.v3.oas.annotations.Operation; import javax.ws.rs.core.MediaType; From ef1021ed30d25269e6a344350225d3c42a426078 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 23 Jan 2025 17:56:02 +0530 Subject: [PATCH 26/71] adding language related changes --- .../data/grievance/GrievanceDetails.java | 29 ++++++++++++++++++- .../grievance/GrievanceDataRepo.java | 9 ++++-- .../grievance/GrievanceDataSyncImpl.java | 17 ++++++++++- 3 files changed, 51 insertions(+), 4 deletions(-) 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 160d0d83..52659c3b 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -96,6 +96,15 @@ public class GrievanceDetails { @Expose @Column(name = "callCounter") private Integer callCounter; + + @Expose + @Column(name = "PreferredLanguageId") + private Integer preferredLanguageId; + + @Expose + @Column(name = "PreferredLanguage") + private String preferredLanguage; + @Column(name = "Deleted", insertable = false, updatable = true) private Boolean deleted = false; @@ -151,7 +160,7 @@ 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, String userid, Boolean isAllocated, - Boolean retryNeeded, Boolean isRegistered, Integer callCounter, Boolean deleted, Character processed, + 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, Integer parkingPlaceID, String syncedBy, Timestamp syncedDate, Boolean isCompleted) { @@ -173,6 +182,8 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long this.retryNeeded = retryNeeded; this.isRegistered = isRegistered; this.callCounter = callCounter; + this.preferredLanguageId = preferredLanguageId; + this.preferredLanguage = preferredLanguage; this.deleted = deleted; this.processed = processed; this.createdBy = createdBy; @@ -324,6 +335,22 @@ public Integer getCallCounter() { public void setCallCounter(Integer callCounter) { this.callCounter = callCounter; } + + public Integer getPreferredLanguageId() { + return preferredLanguageId; + } + + public void setPreferredLanguageId(Integer preferredLanguageId) { + this.preferredLanguageId = preferredLanguageId; + } + + public String getPreferredLanguage() { + return preferredLanguage; + } + + public void setPreferredLanguage(String preferredLanguage) { + this.preferredLanguage = preferredLanguage; + } public Boolean getDeleted() { return deleted; 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 c2a19ccb..8fbbc946 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -3,7 +3,9 @@ +import java.math.BigInteger; import java.time.LocalDateTime; +import java.util.ArrayList; import java.util.List; import org.springframework.data.jpa.repository.Modifying; @@ -26,7 +28,7 @@ public interface GrievanceDataRepo extends CrudRepository findGrievancesInDateRangeAndLanguage( @Param("startDate") LocalDateTime startDate, @Param("endDate") LocalDateTime endDate, @@ -34,9 +36,12 @@ List findGrievancesInDateRangeAndLanguage( @Modifying - @Query("UPDATE Grievance g SET g.isAllocated = true, g.userId = :userId WHERE g.id = :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("userId") Integer userId); + @Query(nativeQuery = true, value = "SELECT PreferredLanguageId, PreferredLanguage, VanSerialNo, VanID, ParkingPlaceId, VehicalNo FROM db_identity.i_beneficiarydetails WHERE BeneficiaryRegID = :benRegId") + public ArrayList getBeneficiaryGrievanceDetails(@Param("benRegId") Long benRegId); + } 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 e13c8387..20919e6e 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -219,7 +219,22 @@ public List> dataSyncToGrievance() { grievance.setState(state); } } - + //setting language related properties and other + ArrayList list1 = grievanceDataRepo.getBeneficiaryGrievanceDetails(grievance.getBeneficiaryRegId()); + for (Object[] objects : list1) { + if (objects != null && objects.length <= 5) { + grievance.setPreferredLanguageId((Integer) objects[0]); + grievance.setPreferredLanguage((String) objects[1]); + grievance.setVanSerialNo((Integer) objects[2]); + grievance.setVanId((Integer) objects[3]); + grievance.setParkingPlaceId((Integer) objects[4]); + grievance.setVehicalNo((String) objects[5]); + + } + } + + + // Setting remaining grievance properties (similar to the existing code) grievance.setAgentId(grievance.getAgentId()); grievance.setDeleted(grievance.getDeleted()); From 3451ad5907e5908c0ea185256a1b896487ff9274 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 23 Jan 2025 19:36:55 +0530 Subject: [PATCH 27/71] add language related changes --- .../iemr/common/repository/grievance/GrievanceDataRepo.java | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) 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 8fbbc946..c97c48bc 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -1,9 +1,6 @@ package com.iemr.common.repository.grievance; - - -import java.math.BigInteger; import java.time.LocalDateTime; import java.util.ArrayList; import java.util.List; @@ -28,7 +25,7 @@ public interface GrievanceDataRepo extends CrudRepository findGrievancesInDateRangeAndLanguage( @Param("startDate") LocalDateTime startDate, @Param("endDate") LocalDateTime endDate, From fa02a49f707ecc41f89d6a10837497ad3a0eb4f9 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 24 Jan 2025 22:07:00 +0530 Subject: [PATCH 28/71] adding name convention related changes --- .../iemr/common/repository/grievance/GrievanceDataRepo.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 c97c48bc..40a1b6f4 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -25,7 +25,7 @@ public interface GrievanceDataRepo extends CrudRepository findGrievancesInDateRangeAndLanguage( @Param("startDate") LocalDateTime startDate, @Param("endDate") LocalDateTime endDate, @@ -33,7 +33,7 @@ List findGrievancesInDateRangeAndLanguage( @Modifying - @Query("UPDATE GrievanceDetails g SET g.isAllocated = true, g.userId = :userId 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("userId") Integer userId); From 822ec19d69314b959e2b3bd12de76bc541334862 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 24 Jan 2025 22:55:53 +0530 Subject: [PATCH 29/71] adding code rabbit changes --- .../grievance/GrievanceDataSyncImpl.java | 2 +- .../GrievanceHandlingServiceImpl.java | 36 +++++++++---------- 2 files changed, 18 insertions(+), 20 deletions(-) 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 20919e6e..b5600c7a 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -222,7 +222,7 @@ public List> dataSyncToGrievance() { //setting language related properties and other ArrayList list1 = grievanceDataRepo.getBeneficiaryGrievanceDetails(grievance.getBeneficiaryRegId()); for (Object[] objects : list1) { - if (objects != null && objects.length <= 5) { + if (objects != null && objects.length >= 6) { grievance.setPreferredLanguageId((Integer) objects[0]); grievance.setPreferredLanguage((String) objects[1]); grievance.setVanSerialNo((Integer) objects[2]); 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 74f3af8c..9358e332 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -52,26 +52,24 @@ public String allocateGrievances(String request) throws Exception { List userIds = allocationRequest.getUserID(); int allocateNo = allocationRequest.getAllocateNo(); // Number of grievances to allocate per user - // Step 5: Allocate grievances to users in a round-robin fashion + for (int i = 0; i < grievances.size(); i++) { - if (i % allocateNo == 0 && userIndex < userIds.size()) { - // Allocate to the next user when reaching the allocateNo threshold - Integer userId = userIds.get(userIndex); - GrievanceDetails grievance = grievances.get(i); - - // Call the repository method to allocate the grievance to the user - int rowsAffected = grievanceDataRepo.allocateGrievance(grievance.getGrievanceId(), userId); - - if (rowsAffected > 0) { - totalAllocated++; - logger.debug("Allocated grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); - } else { - logger.error("Failed to allocate grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); - } - - userIndex = (userIndex + 1) % userIds.size(); - } - } + Integer userId = userIds.get(userIndex); + GrievanceDetails grievance = grievances.get(i); + + int rowsAffected = grievanceDataRepo.allocateGrievance(grievance.getGrievanceId(), userId); + if (rowsAffected > 0) { + totalAllocated++; + logger.debug("Allocated grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); + } else { + logger.error("Failed to allocate grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); + } + + // Move to the next user after allocateNo grievances + if ((i + 1) % allocateNo == 0) { + userIndex = (userIndex + 1) % userIds.size(); + } + } // Step 6: Return a message with the total number of grievances allocated return "Successfully allocated " + totalAllocated + " grievances to users."; From c8e85ab7c7231982e05ba597d245788d749d2743 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 24 Jan 2025 23:18:01 +0530 Subject: [PATCH 30/71] adding sonar quality check suggested changes --- .../grievance/GrievanceController.java | 2 +- .../GrievanceHandlingServiceImpl.java | 20 +++++++++---------- 2 files changed, 11 insertions(+), 11 deletions(-) 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 bb75417a..444cba64 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -63,7 +63,7 @@ public String fetchUnallocatedGrievanceCount() { @Operation(summary = "Allocate grievances to users") - @RequestMapping(value = "/allocateGrievances", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + @PostMapping(value = "/allocateGrievances", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") public String allocateGrievances(@Param(value = "{\"startDate\":\"ISO-8601 format start date (e.g., 2022-12-01T07:49:00.000Z)\", " + "\"endDate\":\"ISO-8601 format end date (e.g., 2025-01-16T07:49:30.561)\", " + "\"userID\":\"Array list of User IDs (agents to be allocated grievances)\", " 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 9358e332..6ade7fc7 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -16,24 +16,24 @@ import com.iemr.common.utils.mapper.InputMapper; @Service -@PropertySource("classpath:application.properties") public class GrievanceHandlingServiceImpl implements GrievanceHandlingService { - private Logger logger = LoggerFactory.getLogger(GrievanceHandlingService.class); + private Logger logger = LoggerFactory.getLogger(GrievanceHandlingServiceImpl.class); + + private final GrievanceDataRepo grievanceDataRepo; + @Autowired - private GrievanceDataRepo grievanceDataRepo; // Repository for grievance-related database operations - - @Value("${grievanceAllocationRetryConfiguration}") - private int grievanceAllocationRetryConfiguration; // Value from application.properties, can be used to configure retry logic + public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo) { + this.grievanceDataRepo = grievanceDataRepo; + } - 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); + 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( @@ -60,9 +60,9 @@ public String allocateGrievances(String request) throws Exception { int rowsAffected = grievanceDataRepo.allocateGrievance(grievance.getGrievanceId(), userId); if (rowsAffected > 0) { totalAllocated++; - logger.debug("Allocated grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); + logger.debug("Allocated grievance ID {} to user ID {}", grievance.getGrievanceId(), userId); } else { - logger.error("Failed to allocate grievance ID " + grievance.getGrievanceId() + " to user ID " + userId); + logger.error("Failed to allocate grievance ID {} to user ID {}", grievance.getGrievanceId(), userId); } // Move to the next user after allocateNo grievances From 6557199b5138879945d4f0f0ac9d36884cbad98c Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 24 Jan 2025 23:23:05 +0530 Subject: [PATCH 31/71] removing unused imports --- .../iemr/common/controller/grievance/GrievanceController.java | 2 -- 1 file changed, 2 deletions(-) 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 444cba64..6126b8bd 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -16,8 +16,6 @@ import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; @RestController From b2d99bec3765a0f334aa7dc46d1dd73d3e32d78f Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Wed, 19 Feb 2025 11:41:12 +0530 Subject: [PATCH 32/71] adding properties related to Grievance in properties file --- src/main/environment/common_ci.properties | 4 +++ src/main/environment/common_dev.properties | 4 ++- .../environment/common_example.properties | 4 +++ src/main/environment/common_test.properties | 4 ++- src/main/environment/common_uat.properties | 4 ++- src/main/resources/application.properties | 25 +++++++++++++++++++ 6 files changed, 42 insertions(+), 3 deletions(-) diff --git a/src/main/environment/common_ci.properties b/src/main/environment/common_ci.properties index cc974456..abf01fd6 100644 --- a/src/main/environment/common_ci.properties +++ b/src/main/environment/common_ci.properties @@ -159,3 +159,7 @@ grievanceDataSyncDuration = @env.GRIEVANCE_DATA_SYNC_DURATION@ springdoc.api-docs.enabled=false springdoc.swagger-ui.enabled=false + +grievanceAllocationRetryConfiguration=1 + + diff --git a/src/main/environment/common_dev.properties b/src/main/environment/common_dev.properties index 411543dd..ee25f9c9 100644 --- a/src/main/environment/common_dev.properties +++ b/src/main/environment/common_dev.properties @@ -184,4 +184,6 @@ grievanceUserAuthenticate = grievanceDataSyncDuration = springdoc.api-docs.enabled=true -springdoc.swagger-ui.enabled=true \ No newline at end of file +springdoc.swagger-ui.enabled=true + +grievanceAllocationRetryConfiguration=1 diff --git a/src/main/environment/common_example.properties b/src/main/environment/common_example.properties index a41e7e63..1c752ac1 100644 --- a/src/main/environment/common_example.properties +++ b/src/main/environment/common_example.properties @@ -186,3 +186,7 @@ grievanceDataSyncDuration = springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true +grievanceAllocationRetryConfiguration=1 + + + diff --git a/src/main/environment/common_test.properties b/src/main/environment/common_test.properties index 30531c1b..fd3de195 100644 --- a/src/main/environment/common_test.properties +++ b/src/main/environment/common_test.properties @@ -186,4 +186,6 @@ grievanceUserAuthenticate = grievanceDataSyncDuration = springdoc.api-docs.enabled=true -springdoc.swagger-ui.enabled=true \ No newline at end of file +springdoc.swagger-ui.enabled=true + +grievanceAllocationRetryConfiguration=1 diff --git a/src/main/environment/common_uat.properties b/src/main/environment/common_uat.properties index f818921f..d0914520 100644 --- a/src/main/environment/common_uat.properties +++ b/src/main/environment/common_uat.properties @@ -157,4 +157,6 @@ grievanceUserAuthenticate = grievanceDataSyncDuration = springdoc.api-docs.enabled=true -springdoc.swagger-ui.enabled=true \ No newline at end of file +springdoc.swagger-ui.enabled=true + +grievanceAllocationRetryConfiguration=1 diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 696c1830..c7cdff88 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -180,3 +180,28 @@ quality-Audit-PageSize=5 ## max no of failed login attempt failedLoginAttempt=5 +##===============================Grievance related properties=========================== +fileBasePath =/Doc +jwt.secret= + + +##grievance API call +updateGrievanceDetails = /grsbepro/igemr1097/public/api/v1/state-wise/grievance-list +updateGrievanceTransactionDetails=/grsbepro/igemr1097/public/api/v1/grievance_details/ + +## grievance variables +grievanceUserName = +grievancePassword = + +grievanceUserAuthenticate = +grievanceDataSyncDuration = + +springdoc.api-docs.enabled=true +springdoc.swagger-ui.enabled=true + +##----------------------------------------------------#grievance data sync----------------------------------------------------------- + +start-grievancedatasync-scheduler=false +cron-scheduler-grievancedatasync=0 0/5 * * * ? * + +grievanceAllocationRetryConfiguration=1 From 76bf328e6130196163bb738a4bb2f28e2f3d0e91 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Wed, 19 Feb 2025 11:42:15 +0530 Subject: [PATCH 33/71] placing the placeholder for jwt secret key --- src/main/resources/application.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index c7cdff88..9e5ce43e 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -182,7 +182,7 @@ failedLoginAttempt=5 ##===============================Grievance related properties=========================== fileBasePath =/Doc -jwt.secret= +jwt.secret= ##grievance API call From eeaf00d56018cfdc5ce5bb2cf90c3d8bdbbe776c Mon Sep 17 00:00:00 2001 From: Srishti gupta <76839176+srishtigrp78@users.noreply.github.com> Date: Wed, 19 Feb 2025 12:22:20 +0530 Subject: [PATCH 34/71] Update package.yml updating upload artifact version to v4 --- .github/workflows/package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/package.yml b/.github/workflows/package.yml index 64777054..69a358ae 100644 --- a/.github/workflows/package.yml +++ b/.github/workflows/package.yml @@ -35,7 +35,7 @@ jobs: run: mvn -B package --file pom.xml - name: Upload WAR file as artifact - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: Common-API From b36477c894927d9f44174f7b1be9d14dfe4c7713 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 20 Feb 2025 11:28:21 +0530 Subject: [PATCH 35/71] removing grievanc related properties from application properties file --- src/main/resources/application.properties | 26 ----------------------- 1 file changed, 26 deletions(-) diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 9e5ce43e..d645f273 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -179,29 +179,3 @@ quality-Audit-PageSize=5 ## max no of failed login attempt failedLoginAttempt=5 - -##===============================Grievance related properties=========================== -fileBasePath =/Doc -jwt.secret= - - -##grievance API call -updateGrievanceDetails = /grsbepro/igemr1097/public/api/v1/state-wise/grievance-list -updateGrievanceTransactionDetails=/grsbepro/igemr1097/public/api/v1/grievance_details/ - -## grievance variables -grievanceUserName = -grievancePassword = - -grievanceUserAuthenticate = -grievanceDataSyncDuration = - -springdoc.api-docs.enabled=true -springdoc.swagger-ui.enabled=true - -##----------------------------------------------------#grievance data sync----------------------------------------------------------- - -start-grievancedatasync-scheduler=false -cron-scheduler-grievancedatasync=0 0/5 * * * ? * - -grievanceAllocationRetryConfiguration=1 From 48ac080eb42134fac8b3d7d0956383041b9cb046 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 20 Feb 2025 11:28:55 +0530 Subject: [PATCH 36/71] adding space --- src/main/resources/application.properties | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index d645f273..1b6b162d 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -175,6 +175,7 @@ everwellmaritalStatusID = 1 everwellbenRelationshipID = 1 everwellDataSyncDuration = 15 + quality-Audit-PageSize=5 ## max no of failed login attempt From 3fe65c437ed0a670deadf775519716a6e8937b6d Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 20 Feb 2025 11:32:39 +0530 Subject: [PATCH 37/71] removing extra space --- src/main/resources/application.properties | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 1b6b162d..d645f273 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -175,7 +175,6 @@ everwellmaritalStatusID = 1 everwellbenRelationshipID = 1 everwellDataSyncDuration = 15 - quality-Audit-PageSize=5 ## max no of failed login attempt From 55c469a2cd8f0ab6f7ad02d807eb453c1ddb37e0 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 20 Feb 2025 16:19:46 +0530 Subject: [PATCH 38/71] adding code for API that fetches grievance outbound worklist --- .../grievance/GrievanceController.java | 38 +++++++++ .../GetGrievanceWorklistRequest.java | 16 ++++ .../dto/grivance/GrievanceTransactionDTO.java | 38 +++++++++ .../dto/grivance/GrievanceWorklistDTO.java | 78 ++++++++++++++++++ .../GrievanceOutboundRepository.java | 24 ++++++ .../grievance/GrievanceHandlingService.java | 8 ++ .../GrievanceHandlingServiceImpl.java | 79 ++++++++++++++++++- 7 files changed, 279 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/iemr/common/data/grievance/GetGrievanceWorklistRequest.java create mode 100644 src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java create mode 100644 src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java create mode 100644 src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java 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 df574a12..dcfea8f7 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -1,11 +1,18 @@ package com.iemr.common.controller.grievance; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + import javax.ws.rs.core.MediaType; import org.json.JSONException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; @@ -13,6 +20,7 @@ import org.springframework.web.bind.annotation.RestController; import com.iemr.common.data.grievance.UnallocationRequest; +import com.iemr.common.dto.grivance.GrievanceWorklistDTO; import com.iemr.common.service.grievance.GrievanceDataSync; import com.iemr.common.service.grievance.GrievanceHandlingService; import com.iemr.common.utils.exception.IEMRException; @@ -117,5 +125,35 @@ public String moveToBin(@RequestBody String request) { } return response.toString(); } + + + + @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\", " + + "\"userId\":\"Optional - Integer ID of user that is assigned to\"}") @RequestBody String request) { + logger.info("Request received for grievance worklist"); + List response = new ArrayList<>(); + try { + response = grievanceHandlingService.getFormattedGrievanceData(request); + + } + + catch (Exception e) { + logger.error("grievanceOutboundWorklist failed with error " + e.getMessage(), e); + List errorResponse = new ArrayList<>(); + GrievanceWorklistDTO errorDTO = new GrievanceWorklistDTO(); + errorDTO.setComplaint("Error fetching grievance data"); + errorDTO.setSubjectOfComplaint(e.getMessage()); + + // Return error response with empty list and error message + errorResponse.add(errorDTO); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse); + } + + + return ResponseEntity.ok(response); + } + } diff --git a/src/main/java/com/iemr/common/data/grievance/GetGrievanceWorklistRequest.java b/src/main/java/com/iemr/common/data/grievance/GetGrievanceWorklistRequest.java new file mode 100644 index 00000000..f0066cde --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GetGrievanceWorklistRequest.java @@ -0,0 +1,16 @@ +package com.iemr.common.data.grievance; + +import lombok.Data; + +@Data +public class GetGrievanceWorklistRequest { + private Integer providerServiceMapID; + private Integer userId; + + // Constructor + public GetGrievanceWorklistRequest(Integer providerServiceMapID, Integer userId) { + this.providerServiceMapID = providerServiceMapID; + this.userId = userId; + } + +} diff --git a/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java b/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java new file mode 100644 index 00000000..c8eebcc4 --- /dev/null +++ b/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java @@ -0,0 +1,38 @@ +package com.iemr.common.dto.grivance; + +import java.io.Serializable; +import java.sql.Timestamp; + + +import lombok.Data; + +@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; + private Timestamp createdAt; + private Timestamp updatedAt; + private String comment; + + // 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; + this.createdAt = createdAt; + this.updatedAt = updatedAt; + this.comment = comment; + } +} diff --git a/src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java b/src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java new file mode 100644 index 00000000..6e4b1604 --- /dev/null +++ b/src/main/java/com/iemr/common/dto/grivance/GrievanceWorklistDTO.java @@ -0,0 +1,78 @@ +package com.iemr.common.dto.grivance; + +import java.io.Serializable; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.List; + + +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +public class GrievanceWorklistDTO implements Serializable { + private static final long serialVersionUID = 1L; + + private String complaintID; + private String subjectOfComplaint; + private String complaint; + private Long beneficiaryRegID; + private Integer providerServiceMapID; + private String firstName; + private String lastName; + private String primaryNumber; + private List transactions = new ArrayList<>(); // transactions list + private String severety; + private String state; + private Integer userId; + private Boolean deleted; + private String createdBy; + private Timestamp createdDate; + private Timestamp lastModDate; + private Boolean isCompleted; + private String gender; + private String district; + private Long beneficiaryID; + private String age; + private Boolean retryNeeded; + private Integer callCounter; + // private String lastCall; // Add this field if you want + + + 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) { + super(); + this.complaintID = complaintID; + this.subjectOfComplaint = subjectOfComplaint; + this.complaint = complaint; + this.beneficiaryRegID = beneficiaryRegID; + this.providerServiceMapID = providerServiceMapID; + this.firstName = firstName; + this.lastName = lastName; + this.primaryNumber = primaryNumber; + this.transactions = transactions; + this.severety = severety; + this.state = state; + this.userId = userId; + this.deleted = deleted; + this.createdBy = createdBy; + this.createdDate = createdDate; + this.lastModDate = lastModDate; + this.isCompleted = isCompleted; + this.gender = gender; + this.district = district; + this.beneficiaryID = beneficiaryID; + this.age = age; + this.retryNeeded = retryNeeded; + this.callCounter = callCounter; + } + + + + +} diff --git a/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java new file mode 100644 index 00000000..4655d45c --- /dev/null +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java @@ -0,0 +1,24 @@ +package com.iemr.common.repository.grievance; + +import java.util.List; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.query.Procedure; +import org.springframework.stereotype.Repository; + +import com.iemr.common.data.grievance.GrievanceDetails; +import com.iemr.common.data.grievance.GrievanceWorklist; +import com.iemr.common.dto.grivance.GrievanceWorklistDTO; + +import io.lettuce.core.dynamic.annotation.Param; +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); + +} 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 49065db7..cbefc8b7 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java @@ -1,8 +1,12 @@ package com.iemr.common.service.grievance; +import java.util.List; +import java.util.Map; + import org.json.JSONException; import org.springframework.stereotype.Service; +import com.iemr.common.dto.grivance.GrievanceWorklistDTO; import com.iemr.common.utils.exception.IEMRException; @Service @@ -14,5 +18,9 @@ public interface GrievanceHandlingService { public String reallocateGrievances(String request) throws Exception; public String moveToBin(String request) throws Exception; + +// public Map getGrievanceOutboundWorklist(String request) throws Exception; + + public List getFormattedGrievanceData(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 c79dd3de..4712befe 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -1,10 +1,14 @@ package com.iemr.common.service.grievance; +import java.sql.Timestamp; import java.util.ArrayList; import java.util.Comparator; +import java.util.HashMap; import java.util.Iterator; import java.util.List; +import java.util.Map; import java.util.Set; +import java.util.stream.Collectors; import org.json.JSONArray; import org.json.JSONException; @@ -13,26 +17,36 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; +import org.springframework.http.HttpStatus; import org.springframework.stereotype.Service; +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.GrievanceWorklist; 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.grievance.GrievanceDataRepo; +import com.iemr.common.repository.grievance.GrievanceOutboundRepository; import com.iemr.common.utils.exception.IEMRException; import com.iemr.common.utils.mapper.InputMapper; +import jakarta.transaction.Transactional; + @Service public class GrievanceHandlingServiceImpl implements GrievanceHandlingService { private Logger logger = LoggerFactory.getLogger(GrievanceHandlingServiceImpl.class); private final GrievanceDataRepo grievanceDataRepo; + private final GrievanceOutboundRepository grievanceOutboundRepo; @Autowired - public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo) { + public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo, GrievanceOutboundRepository grievanceOutboundRepo) { this.grievanceDataRepo = grievanceDataRepo; + this.grievanceOutboundRepo = grievanceOutboundRepo; } @Value("${grievanceAllocationRetryConfiguration}") @@ -233,5 +247,66 @@ public String moveToBin(String request) throws Exception { // Step 5: Return the response as count of successfully unassigned grievances return totalUnassigned + " grievances successfully moved to bin."; } - + + @Transactional + public List getFormattedGrievanceData(String request) throws Exception { + GetGrievanceWorklistRequest getGrievanceWorklistRequest = InputMapper.gson().fromJson(request, GetGrievanceWorklistRequest.class); + + List formattedGrievances = new ArrayList<>(); + + // Fetch grievance worklist data using @Procedure annotation + List worklistData = grievanceOutboundRepo.getGrievanceWorklistData(getGrievanceWorklistRequest.getProviderServiceMapID(), getGrievanceWorklistRequest.getUserId()); + + // Loop through the worklist data and format the response + for (Object[] row : worklistData) { + 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[19], // firstName + (String) row[20], // lastName + + new ArrayList<>(),// transactions (initially empty, will be populated later) + (String) row[11], // severety + (String) row[12], // state + (Integer) row[13],// userId + (Boolean) row[14],// deleted + (String) row[15],// createdBy + (Timestamp) row[16], // createdDate + (Timestamp) row[17], // lastModDate + (Boolean) row[18], // isCompleted + (String) row[21], // gender + (String) row[22], // district + (Long) row[23], // beneficiaryID + (String) row[24], // age + (Boolean) row[25], // retryNeeded + (Integer) row[26] // callCounter + //(String) row[22] // lastCall + ); + + // Extract transactions from the current row and add them to the grievance object + GrievanceTransactionDTO transaction = new GrievanceTransactionDTO( + // (String) row[23], // actionTakenBy + // (String) row[24], // status + (String) row[22], // fileName + (String) row[6], // fileType + (String) row[7], // redressed + (Timestamp) row[8], // createdAt + (Timestamp) row[9], // updatedAt + (String) row[10] // comment + ); + + grievance.getTransactions().add(transaction); // Add the transaction to the grievance's list + + // Add the grievance to the result list + formattedGrievances.add(grievance); + } + + return formattedGrievances; + + } } From 584f97e3b9a3b915fead85d733e9f5c93b693c16 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 21 Feb 2025 10:59:34 +0530 Subject: [PATCH 39/71] adding code rabbit suggested changes --- .../dto/grivance/GrievanceTransactionDTO.java | 5 ----- .../grievance/GrievanceOutboundRepository.java | 5 ++--- .../grievance/GrievanceHandlingService.java | 3 --- .../grievance/GrievanceHandlingServiceImpl.java | 14 ++++++-------- 4 files changed, 8 insertions(+), 19 deletions(-) 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 c8eebcc4..6243e001 100644 --- a/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java +++ b/src/main/java/com/iemr/common/dto/grivance/GrievanceTransactionDTO.java @@ -10,8 +10,6 @@ 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; @@ -22,12 +20,9 @@ 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/repository/grievance/GrievanceOutboundRepository.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java index 4655d45c..88c50d66 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java @@ -4,13 +4,12 @@ import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.query.Procedure; +import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; import com.iemr.common.data.grievance.GrievanceDetails; -import com.iemr.common.data.grievance.GrievanceWorklist; -import com.iemr.common.dto.grivance.GrievanceWorklistDTO; -import io.lettuce.core.dynamic.annotation.Param; + import jakarta.transaction.Transactional; @Repository 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 cbefc8b7..1f8ecd6a 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java @@ -1,7 +1,6 @@ package com.iemr.common.service.grievance; import java.util.List; -import java.util.Map; import org.json.JSONException; import org.springframework.stereotype.Service; @@ -19,8 +18,6 @@ public interface GrievanceHandlingService { public String moveToBin(String request) throws Exception; -// public Map getGrievanceOutboundWorklist(String request) throws Exception; - public List getFormattedGrievanceData(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 4712befe..c367d0dc 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -3,12 +3,9 @@ import java.sql.Timestamp; import java.util.ArrayList; import java.util.Comparator; -import java.util.HashMap; import java.util.Iterator; import java.util.List; -import java.util.Map; import java.util.Set; -import java.util.stream.Collectors; import org.json.JSONArray; import org.json.JSONException; @@ -17,14 +14,12 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; -import org.springframework.http.HttpStatus; import org.springframework.stereotype.Service; 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.GrievanceWorklist; import com.iemr.common.data.grievance.MoveToBinRequest; import com.iemr.common.dto.grivance.GrievanceTransactionDTO; import com.iemr.common.dto.grivance.GrievanceWorklistDTO; @@ -259,6 +254,11 @@ public List getFormattedGrievanceData(String request) thro // Loop through the worklist data and format the response for (Object[] row : worklistData) { + if (row == null || row.length < 27) + { + logger.warn("invalid row data received"); + continue; + } GrievanceWorklistDTO grievance = new GrievanceWorklistDTO( (String) row[0], // complaintID (String) row[1], // subjectOfComplaint @@ -285,13 +285,11 @@ public List getFormattedGrievanceData(String request) thro (String) row[24], // age (Boolean) row[25], // retryNeeded (Integer) row[26] // callCounter - //(String) row[22] // lastCall ); // Extract transactions from the current row and add them to the grievance object GrievanceTransactionDTO transaction = new GrievanceTransactionDTO( - // (String) row[23], // actionTakenBy - // (String) row[24], // status + (String) row[22], // fileName (String) row[6], // fileType (String) row[7], // redressed From 4a4de76be701dad1dce1f2a854625100daeae01e Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 21 Feb 2025 11:29:53 +0530 Subject: [PATCH 40/71] another addition of code rabbit suggested changes --- .../GrievanceHandlingServiceImpl.java | 25 ++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) 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 c367d0dc..1c164b06 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -245,13 +245,32 @@ public String moveToBin(String request) throws Exception { @Transactional public List getFormattedGrievanceData(String request) throws Exception { + if (request == null || request.trim().isEmpty()) { + throw new IllegalArgumentException("Request cannot be null or empty"); + } + GetGrievanceWorklistRequest getGrievanceWorklistRequest = InputMapper.gson().fromJson(request, GetGrievanceWorklistRequest.class); List formattedGrievances = new ArrayList<>(); // Fetch grievance worklist data using @Procedure annotation - List worklistData = grievanceOutboundRepo.getGrievanceWorklistData(getGrievanceWorklistRequest.getProviderServiceMapID(), getGrievanceWorklistRequest.getUserId()); - + List worklistData; + try { + if (getGrievanceWorklistRequest.getProviderServiceMapID() == null || + getGrievanceWorklistRequest.getUserId() == null) { + throw new IllegalArgumentException("ProviderServiceMapID and UserId are required"); + } + worklistData = grievanceOutboundRepo.getGrievanceWorklistData(getGrievanceWorklistRequest.getProviderServiceMapID(), getGrievanceWorklistRequest.getUserId()); + if (worklistData == null || worklistData.isEmpty()) { + logger.info("No grievance data found for the given criteria"); + return new ArrayList<>(); + } + } + catch (Exception e) { + logger.error("Failed to fetch grievance data: {}", e.getMessage()); + throw new Exception("Failed to retrieve grievance data", e); + } + // Loop through the worklist data and format the response for (Object[] row : worklistData) { if (row == null || row.length < 27) @@ -290,7 +309,7 @@ public List getFormattedGrievanceData(String request) thro // Extract transactions from the current row and add them to the grievance object GrievanceTransactionDTO transaction = new GrievanceTransactionDTO( - (String) row[22], // fileName + (String) row[6], // fileName (String) row[6], // fileType (String) row[7], // redressed (Timestamp) row[8], // createdAt From 650e5730fad9c91ed17b7efcd789cb7332939b9b Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 21 Feb 2025 11:41:32 +0530 Subject: [PATCH 41/71] fixing row no --- .../GrievanceHandlingServiceImpl.java | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) 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 1c164b06..f850f1f5 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -273,7 +273,7 @@ public List getFormattedGrievanceData(String request) thro // Loop through the worklist data and format the response for (Object[] row : worklistData) { - if (row == null || row.length < 27) + if (row == null || row.length < 28) { logger.warn("invalid row data received"); continue; @@ -286,35 +286,35 @@ public List getFormattedGrievanceData(String request) thro (Integer) row[4],// providerServiceMapID (String) row[5], // primaryNumber - (String) row[19], // firstName - (String) row[20], // lastName + (String) row[20], // firstName + (String) row[21], // lastName new ArrayList<>(),// transactions (initially empty, will be populated later) - (String) row[11], // severety - (String) row[12], // state - (Integer) row[13],// userId - (Boolean) row[14],// deleted - (String) row[15],// createdBy - (Timestamp) row[16], // createdDate - (Timestamp) row[17], // lastModDate - (Boolean) row[18], // isCompleted - (String) row[21], // gender - (String) row[22], // district - (Long) row[23], // beneficiaryID - (String) row[24], // age - (Boolean) row[25], // retryNeeded - (Integer) row[26] // callCounter + (String) row[12], // severety + (String) row[13], // state + (Integer) row[14],// userId + (Boolean) row[15],// deleted + (String) row[16],// createdBy + (Timestamp) row[17], // createdDate + (Timestamp) row[18], // lastModDate + (Boolean) row[19], // isCompleted + (String) row[22], // gender + (String) row[23], // district + (Long) row[24], // beneficiaryID + (String) row[25], // age + (Boolean) row[26], // retryNeeded + (Integer) row[27] // callCounter ); // Extract transactions from the current row and add them to the grievance object GrievanceTransactionDTO transaction = new GrievanceTransactionDTO( (String) row[6], // fileName - (String) row[6], // fileType - (String) row[7], // redressed - (Timestamp) row[8], // createdAt - (Timestamp) row[9], // updatedAt - (String) row[10] // comment + (String) row[7], // fileType + (String) row[8], // redressed + (Timestamp) row[9], // createdAt + (Timestamp) row[10], // updatedAt + (String) row[11] // comment ); grievance.getTransactions().add(transaction); // Add the transaction to the grievance's list From 45b088e8a2b60cf785d63cb53be2136f267f05c0 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 21 Feb 2025 15:01:43 +0530 Subject: [PATCH 42/71] adding code for API to save complaint resolution and remarks in the db --- .../grievance/GrievanceController.java | 12 +++++++++ .../data/grievance/GrievanceDetails.java | 14 +++++++++- .../grievance/GrievanceDataRepo.java | 23 ++++++++++++++++ .../grievance/GrievanceHandlingService.java | 2 ++ .../GrievanceHandlingServiceImpl.java | 27 +++++++++++++++++++ 5 files changed, 77 insertions(+), 1 deletion(-) 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..728b0b08 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -156,4 +156,16 @@ public ResponseEntity> getGrievanceOutboundWorklist(@ } + @PostMapping(value = "/saveComplaintResolution", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") + public String saveComplaintResolution(@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(); + } + } 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..ec5264c1 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; @@ -106,6 +107,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; @@ -161,7 +171,7 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long Integer providerServiceMapID, String complaintID, String subjectOfComplaint, String complaint, String primaryNumber, String severety, String state, String agentID, Integer userid, Boolean isAllocated, Boolean retryNeeded, Boolean isRegistered, Integer callCounter, Integer preferredLanguageId, - String preferredLanguage, Boolean deleted, Character processed, String createdBy, Timestamp createdDate, + String preferredLanguage, String complaintResolution, String remarks, Boolean deleted, Character processed, String createdBy, Timestamp createdDate, String modifiedBy, Timestamp lastModDate, Integer vanSerialNo, Integer vanID, String vehicalNo, Integer parkingPlaceID, String syncedBy, Timestamp syncedDate, Boolean isCompleted) { super(); @@ -184,6 +194,8 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long 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/repository/grievance/GrievanceDataRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java index 151ab91d..013d042b 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -70,5 +70,28 @@ int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, @Query("Select grievance.preferredLanguage, count(grievance) from GrievanceDetails grievance where grievance.isAllocated=false group by grievance.preferredLanguage") public Set fetchUnallocatedGrievanceCount(); + + @Modifying + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks " + + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + + " AND g.assignedUserID = :assignedUserID") + @Transactional + int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, + @Param("remarks") String remark, + @Param("complaintID") String complaintID, + @Param("beneficiaryRegID") Long beneficiaryRegID, + @Param("providerServiceMapID") Integer providerServiceMapID, + @Param("assignedUserID") Integer assignedUserID); + + @Modifying + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution " + + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + + " AND g.assignedUserID = :assignedUserID") + @Transactional + int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, + @Param("complaintID") String complaintID, + @Param("beneficiaryRegID") Long beneficiaryRegID, + @Param("providerServiceMapID") Integer providerServiceMapID, + @Param("assignedUserID") Integer assignedUserID); } 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..cb3c32a0 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,6 @@ public interface GrievanceHandlingService { public List getFormattedGrievanceData(String request) throws Exception; + public String saveComplaintResolution(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..92a63b2a 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -326,4 +326,31 @@ public List getFormattedGrievanceData(String request) thro return formattedGrievances; } + + public String saveComplaintResolution(String request) throws Exception { + // Parse the request JSON into a GrievanceDetails object + GrievanceDetails grievanceRequest = InputMapper.gson().fromJson(request, GrievanceDetails.class); + + // 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 assignedUserID = grievanceRequest.getAssignedUserID(); + + int updateCount = 0; + if (remarks == null) { + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution,complaintID, + beneficiaryRegID, providerServiceMapID, assignedUserID); + } + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, complaintID, + beneficiaryRegID, providerServiceMapID, assignedUserID); + + if (updateCount > 0) { + return "Complaint resolution updated successfully."; + } else { + throw new Exception("Failed to update complaint resolution."); + } + } } From aaf8db8085b5da69ebb1c882c89904807d3e3909 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 24 Feb 2025 12:00:04 +0530 Subject: [PATCH 43/71] adding code rabbit suggested changes --- .../grievance/GrievanceController.java | 12 +++++- .../data/grievance/GrievanceDetails.java | 2 +- .../grievance/GrievanceDataRepo.java | 8 +++- .../GrievanceHandlingServiceImpl.java | 41 +++++++++++++++++-- 4 files changed, 54 insertions(+), 9 deletions(-) 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 10cb0f83..581f71ef 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -157,9 +157,17 @@ public ResponseEntity> getGrievanceOutboundWorklist(@ - + @Operation(summary = "Save complaint resolution and remarks") @PostMapping(value = "/saveComplaintResolution", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON, headers = "Authorization") - public String saveComplaintResolution(@RequestBody String request) { + public String saveComplaintResolution( @Param(value = "{\"complaintID\":\"Complaint ID string\", " + + "\"complaintResolution\":\"Resolution text\", " + + "\"remarks\":\"Optional remarks\", " + + "\"beneficiaryRegID\":\"Beneficiary registration ID\", " + + "\"providerServiceMapID\":\"Provider service map ID\", " + + "\"assignedUserID\":\"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)); 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 ec5264c1..3ad589a7 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -114,7 +114,7 @@ public class GrievanceDetails { @Expose @Column(name = "Remarks") - //@Size(max = 5000, message = "Remarks cannot exceed 5000 characters") + @Size(max = 5000, message = "Remarks cannot exceed 5000 characters") private String remarks; @Column(name = "Deleted", insertable = false, updatable = true) 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 013d042b..5ebcaa5f 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -72,23 +72,27 @@ int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, public Set fetchUnallocatedGrievanceCount(); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy, g.lastModDate = :lastModDate " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.assignedUserID = :assignedUserID") @Transactional int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, @Param("remarks") String remark, + @Param("modifiedBy") String modifiedBy, + @Param("lastModDate") Timestamp lastModDate, @Param("complaintID") String complaintID, @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, @Param("assignedUserID") Integer assignedUserID); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy, g.lastModDate = :lastModDate " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.assignedUserID = :assignedUserID") @Transactional int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, + @Param("modifiedBy") String modifiedBy, + @Param("lastModDate") Timestamp lastModDate, @Param("complaintID") String complaintID, @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, 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 6467a14d..73628b1b 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -327,11 +327,36 @@ public List getFormattedGrievanceData(String request) thro } - + /** + * 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.getAssignedUserID() == null) { + throw new IllegalArgumentException("AssignedUserID is required"); + } + if (grievanceRequest.getCreatedBy() == null) { + throw new IllegalArgumentException("CreatedBy is required"); + } // Extract values from the request String complaintID = grievanceRequest.getComplaintID(); String complaintResolution = grievanceRequest.getComplaintResolution(); @@ -339,15 +364,23 @@ public String saveComplaintResolution(String request) throws Exception { Long beneficiaryRegID = grievanceRequest.getBeneficiaryRegID(); Integer providerServiceMapID = grievanceRequest.getProviderServiceMapID(); Integer assignedUserID = grievanceRequest.getAssignedUserID(); - + String createdBy = grievanceRequest.getCreatedBy(); + Timestamp lastModDate = new Timestamp(System.currentTimeMillis()); // Get current system time as Timestamp + + + String modifiedBy = createdBy; int updateCount = 0; if (remarks == null) { - updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution,complaintID, + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, modifiedBy, lastModDate, complaintID, beneficiaryRegID, providerServiceMapID, assignedUserID); + logger.debug("updated complaint resolution without remarks for complaint id: {}", complaintID); } - updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, complaintID, + else { + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, modifiedBy, lastModDate, complaintID, beneficiaryRegID, providerServiceMapID, assignedUserID); + logger.debug("updated complaint resolution with remarks for complaint id: {}", complaintID); + } if (updateCount > 0) { return "Complaint resolution updated successfully."; } else { From 713867ec2fe450745007ed7ac39f2afa654d4b6e Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 24 Feb 2025 13:12:13 +0530 Subject: [PATCH 44/71] removing lastModDate as it will update automatically in db --- .../iemr/common/repository/grievance/GrievanceDataRepo.java | 6 ++---- .../service/grievance/GrievanceHandlingServiceImpl.java | 5 ++--- 2 files changed, 4 insertions(+), 7 deletions(-) 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 5ebcaa5f..f5b0bbf4 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -72,27 +72,25 @@ int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, public Set fetchUnallocatedGrievanceCount(); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy, g.lastModDate = :lastModDate " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy, " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.assignedUserID = :assignedUserID") @Transactional int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, @Param("remarks") String remark, @Param("modifiedBy") String modifiedBy, - @Param("lastModDate") Timestamp lastModDate, @Param("complaintID") String complaintID, @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, @Param("assignedUserID") Integer assignedUserID); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy, g.lastModDate = :lastModDate " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy, " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.assignedUserID = :assignedUserID") @Transactional int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, @Param("modifiedBy") String modifiedBy, - @Param("lastModDate") Timestamp lastModDate, @Param("complaintID") String complaintID, @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, 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 73628b1b..4eb6b4a7 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -365,18 +365,17 @@ public String saveComplaintResolution(String request) throws Exception { Integer providerServiceMapID = grievanceRequest.getProviderServiceMapID(); Integer assignedUserID = grievanceRequest.getAssignedUserID(); String createdBy = grievanceRequest.getCreatedBy(); - Timestamp lastModDate = new Timestamp(System.currentTimeMillis()); // Get current system time as Timestamp String modifiedBy = createdBy; int updateCount = 0; if (remarks == null) { - updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, modifiedBy, lastModDate, complaintID, + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, modifiedBy, complaintID, beneficiaryRegID, providerServiceMapID, assignedUserID); logger.debug("updated complaint resolution without remarks for complaint id: {}", complaintID); } else { - updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, modifiedBy, lastModDate, complaintID, + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, modifiedBy, complaintID, beneficiaryRegID, providerServiceMapID, assignedUserID); logger.debug("updated complaint resolution with remarks for complaint id: {}", complaintID); From 42f00cea45222705ae1abb1fbce64dc90dc1f215 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 24 Feb 2025 22:32:31 +0530 Subject: [PATCH 45/71] changing variable name of assignedUserID to userID --- .../grievance/GrievanceController.java | 4 +-- .../data/grievance/GrievanceDetails.java | 4 +-- .../data/grievance/MoveToBinRequest.java | 2 +- .../grievance/GrievanceDataRepo.java | 32 +++++++++---------- .../GrievanceHandlingServiceImpl.java | 22 ++++++------- 5 files changed, 32 insertions(+), 32 deletions(-) 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 581f71ef..b422a240 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -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)); @@ -164,7 +164,7 @@ public String saveComplaintResolution( @Param(value = "{\"complaintID\":\" "\"remarks\":\"Optional remarks\", " + "\"beneficiaryRegID\":\"Beneficiary registration ID\", " + "\"providerServiceMapID\":\"Provider service map ID\", " + - "\"assignedUserID\":\"Assigned user ID\", " + + "\"userID\":\"Assigned user ID\", " + "\"createdBy\":\"Creator of the complaint\", " + "\"benCallID\":\"Beneficiary call ID\"}") @RequestBody String request) { 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 3ad589a7..910ab886 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -82,7 +82,7 @@ public class GrievanceDetails { @Expose @Column(name = "userid") - private Integer assignedUserID; + private Integer userID; @Expose @Column(name = "isAllocated") @@ -187,7 +187,7 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long this.severety = severety; this.state = state; this.agentid = agentID; - this.assignedUserID = userid; + this.userID = userid; this.isAllocated = isAllocated; this.retryNeeded = retryNeeded; this.isRegistered = isRegistered; 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/repository/grievance/GrievanceDataRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java index f5b0bbf4..d3fff2da 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -27,40 +27,40 @@ 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") public ArrayList getBeneficiaryGrievanceDetails(@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 = NULL WHERE g.grievanceId = :grievanceId AND g.userID = :userID") + int unassignGrievance(@Param("grievanceId") Long grievanceId, @Param("userID") Integer userID); @Modifying @Transactional @@ -74,7 +74,7 @@ int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, @Modifying @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy, " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" - + " AND g.assignedUserID = :assignedUserID") + + " AND g.userID = :userID") @Transactional int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, @Param("remarks") String remark, @@ -82,18 +82,18 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso @Param("complaintID") String complaintID, @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, - @Param("assignedUserID") Integer assignedUserID); + @Param("userID") Integer userID); @Modifying @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy, " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" - + " AND g.assignedUserID = :assignedUserID") + + " AND g.userID = :userID") @Transactional int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, @Param("modifiedBy") String modifiedBy, @Param("complaintID") String complaintID, @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, - @Param("assignedUserID") Integer assignedUserID); + @Param("userID") Integer userID); } 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 4eb6b4a7..bf83074b 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -104,9 +104,9 @@ public String allocatedGrievanceRecordsCount(String request) throws IEMRExceptio 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); @@ -194,7 +194,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."); @@ -220,7 +220,7 @@ public String moveToBin(String request) throws Exception { int totalUnassigned = 0; for (GrievanceDetails grievance : grievancesToMove) { int rowsAffected = grievanceDataRepo.unassignGrievance(grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + moveToBinRequest.getUserID()); if (rowsAffected > 0) { grievance.setIsAllocated(false); // Assuming there's a setter for this flag int updateFlagResult = grievanceDataRepo.updateGrievanceAllocationStatus(grievance.getGrievanceId(), @@ -228,14 +228,14 @@ public String moveToBin(String request) throws Exception { if (updateFlagResult > 0) { totalUnassigned++; logger.debug("Unassigned grievance ID {} from user ID {}", grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + moveToBinRequest.getUserID()); } else { logger.error("Failed to unassign grievance ID {} from user ID {}", grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + moveToBinRequest.getUserID()); } } else { logger.error("Failed to unassign grievance ID {} from user ID {}", grievance.getGrievanceId(), - moveToBinRequest.getAssignedUserID()); + moveToBinRequest.getUserID()); } } @@ -351,7 +351,7 @@ public String saveComplaintResolution(String request) throws Exception { if (grievanceRequest.getProviderServiceMapID() == null) { throw new IllegalArgumentException("ProviderServiceMapID is required"); } - if (grievanceRequest.getAssignedUserID() == null) { + if (grievanceRequest.getUserID() == null) { throw new IllegalArgumentException("AssignedUserID is required"); } if (grievanceRequest.getCreatedBy() == null) { @@ -363,7 +363,7 @@ public String saveComplaintResolution(String request) throws Exception { String remarks = grievanceRequest.getRemarks(); Long beneficiaryRegID = grievanceRequest.getBeneficiaryRegID(); Integer providerServiceMapID = grievanceRequest.getProviderServiceMapID(); - Integer assignedUserID = grievanceRequest.getAssignedUserID(); + Integer userID = grievanceRequest.getUserID(); String createdBy = grievanceRequest.getCreatedBy(); @@ -371,12 +371,12 @@ public String saveComplaintResolution(String request) throws Exception { int updateCount = 0; if (remarks == null) { updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, modifiedBy, complaintID, - beneficiaryRegID, providerServiceMapID, assignedUserID); + beneficiaryRegID, providerServiceMapID, userID); logger.debug("updated complaint resolution without remarks for complaint id: {}", complaintID); } else { updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, modifiedBy, complaintID, - beneficiaryRegID, providerServiceMapID, assignedUserID); + beneficiaryRegID, providerServiceMapID, userID); logger.debug("updated complaint resolution with remarks for complaint id: {}", complaintID); } From f2478cd3a5bde2bbf4bd72476f9aa78afb2edc16 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 25 Feb 2025 11:27:00 +0530 Subject: [PATCH 46/71] fixing remarks --- .../com/iemr/common/repository/grievance/GrievanceDataRepo.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 d3fff2da..f69c2ecd 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -77,7 +77,7 @@ int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, + " AND g.userID = :userID") @Transactional int updateComplaintResolution(@Param("complaintResolution") String complaintResolution, - @Param("remarks") String remark, + @Param("remarks") String remarks, @Param("modifiedBy") String modifiedBy, @Param("complaintID") String complaintID, @Param("beneficiaryRegID") Long beneficiaryRegID, From c1cabf670c5b0c5a008d0de3f7e9d72d12f01936 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 25 Feb 2025 11:47:38 +0530 Subject: [PATCH 47/71] removing full stop --- .../service/grievance/GrievanceHandlingServiceImpl.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 bf83074b..094183db 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -381,9 +381,9 @@ public String saveComplaintResolution(String request) throws Exception { } if (updateCount > 0) { - return "Complaint resolution updated successfully."; + return "Complaint resolution updated successfully"; } else { - throw new Exception("Failed to update complaint resolution."); + throw new Exception("Failed to update complaint resolution"); } } From 8b9059ad6b6b72a3e29f9f87a4c02f4f5d042777 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 27 Feb 2025 13:12:53 +0530 Subject: [PATCH 48/71] adding code for API to close call and make reattempts if needed --- src/main/environment/common_ci.properties | 2 +- src/main/environment/common_dev.properties | 2 +- .../environment/common_example.properties | 2 +- src/main/environment/common_test.properties | 2 +- src/main/environment/common_uat.properties | 2 +- .../grievance/GrievanceController.java | 30 +++++ .../data/grievance/GrievanceCallRequest.java | 17 +++ .../IEMRCalltypeRepositoryImplCustom.java | 4 +- .../grievance/GrievanceDataRepo.java | 30 ++++- .../service/grievance/GrievanceDataSync.java | 2 + .../grievance/GrievanceDataSyncImpl.java | 121 +++++++++++++++++- 11 files changed, 204 insertions(+), 10 deletions(-) create mode 100644 src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java 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 b422a240..d364338c 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -178,5 +178,35 @@ public String saveComplaintResolution( @Param(value = "{\"complaintID\":\" 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(); + } + + } 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..d485e739 --- /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/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java b/src/main/java/com/iemr/common/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java index 8a5d3d29..92d767ca 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 callType, callGroupType 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 f69c2ecd..ca16bf4f 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -72,7 +72,7 @@ int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, public Set fetchUnallocatedGrievanceCount(); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy, " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.userID = :userID") @Transactional @@ -85,7 +85,7 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso @Param("userID") Integer userID); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy, " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.userID = :userID") @Transactional @@ -95,5 +95,31 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, @Param("userID") Integer userID); + + @Query(" Select grievance.callCounter, grievance.retryNeeded FROM GrievanceDetails grievance where complaintID = :complaintID") + public ArrayList getCallCounter(@Param("complaintID") String complaintID); + + @Query("UPDATE GrievanceDetails g SET g.isCompleted = :isCompleted " + + "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("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); } 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..d0d32f2e 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -12,4 +12,6 @@ public interface GrievanceDataSync { public String fetchUnallocatedGrievanceCount(String preferredLanguage) 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..0b3a218c 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; @@ -32,9 +33,12 @@ 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.everwell.EverwellDetails; +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 { @@ -62,16 +68,18 @@ public class GrievanceDataSyncImpl implements GrievanceDataSync { 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,6 +100,9 @@ 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; @@ -468,4 +479,110 @@ 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(); + // String createdBy = grievanceCallRequest.getCreatedBy(); + + GrievanceDetails grievanceDetails = new GrievanceDetails(); + CallType callTypeObj = new CallType(); + String response = "failure"; + int updateCount = 0; + int updateCallCounter = 0; + int callCounter = 0; + try { + + // GrievanceDetails grievanceCallStatus = grievanceDataRepo.getCallCounter(complaintID); + GrievanceDetails grievanceCallStatus = new GrievanceDetails(); + + // List outboundCallRequests = new ArrayList(); + ArrayList 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[0]); + + } + + } + + String callGroupType = callTypeObj.getCallGroupType(); + String callType = callTypeObj.getCallType(); + + + // Logic for reattempt based on state and call type + // boolean isRetryNeeded = false; + + boolean isRetryNeeded = grievanceCallStatus.getRetryNeeded(); + if (callGroupType.equals("Valid")) { + // Conditions when no reattempt is needed + if (callType.equals("Valid") || callType.equals("Wrong Number") || 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; + } + } + + // Check if max attempts (3) are reached + if (isRetryNeeded == true && callCounter < grievanceAllocationRetryConfiguration) { + // Increment the call counter for reattempt + grievanceDetails.setCallCounter(grievanceDetails.getCallCounter() + 1); + // Update the retryNeeded flag + grievanceDetails.setRetryNeeded(true); + updateCallCounter = grievanceDataRepo.updateCallCounter(grievanceDetails.getCallCounter(),grievanceDetails.getRetryNeeded(), grievanceCallRequest.getComplaintID(), + grievanceCallRequest.getBeneficiaryRegID(), grievanceCallRequest.getProviderServiceMapId(), + grievanceCallRequest.getUserID()); + // response = "Successfully closing call."; // 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"; + } + } else if (callCounter == grievanceAllocationRetryConfiguration) { + // Max attempts reached, no further reattempt + updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, complaintID, userID, beneficiaryRegID, providerServiceMapId); + grievanceDetails.setRetryNeeded(false); + 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) + } + } From 2f724d31f37c2e9a6a67f5f08f9ee1e77a17670f Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 27 Feb 2025 13:53:47 +0530 Subject: [PATCH 49/71] adding code changes suggested by code rabbit --- .../grievance/GrievanceDataRepo.java | 3 ++- .../grievance/GrievanceDataSyncImpl.java | 18 +++++++----------- 2 files changed, 9 insertions(+), 12 deletions(-) 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 ca16bf4f..db261bf7 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -97,8 +97,9 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso @Param("userID") Integer userID); @Query(" Select grievance.callCounter, grievance.retryNeeded FROM GrievanceDetails grievance where complaintID = :complaintID") - public ArrayList getCallCounter(@Param("complaintID") String complaintID); + public List getCallCounter(@Param("complaintID") String complaintID); + @Modifying @Query("UPDATE GrievanceDetails g SET g.isCompleted = :isCompleted " + "WHERE g.complaintID = :complaintID AND g.userID = :userID AND g.beneficiaryRegID = :beneficiaryRegID " + "AND g.providerServiceMapID = :providerServiceMapID") 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 0b3a218c..c2965e56 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -493,21 +493,17 @@ public String completeGrievanceCall(String request) throws Exception { Long beneficiaryRegID = grievanceCallRequest.getBeneficiaryRegID(); Integer callTypeID = grievanceCallRequest.getCallTypeID(); Integer providerServiceMapId = grievanceCallRequest.getProviderServiceMapId(); - // String createdBy = grievanceCallRequest.getCreatedBy(); - GrievanceDetails grievanceDetails = new GrievanceDetails(); CallType callTypeObj = new CallType(); - String response = "failure"; + String response = "failure"; int updateCount = 0; int updateCallCounter = 0; int callCounter = 0; try { - // GrievanceDetails grievanceCallStatus = grievanceDataRepo.getCallCounter(complaintID); GrievanceDetails grievanceCallStatus = new GrievanceDetails(); - // List outboundCallRequests = new ArrayList(); - ArrayList lists = grievanceDataRepo.getCallCounter(complaintID); + List lists = grievanceDataRepo.getCallCounter(complaintID); for (Object[] objects : lists) { if (objects != null && objects.length >= 2) { grievanceCallStatus.setCallCounter((Integer) objects[0]); @@ -523,7 +519,7 @@ public String completeGrievanceCall(String request) throws Exception { if (object != null && object.length >= 2) { callTypeObj.setCallGroupType((String) object[0]); - callTypeObj.setCallType((String) object[0]); + callTypeObj.setCallType((String) object[1]); } @@ -551,10 +547,10 @@ public String completeGrievanceCall(String request) throws Exception { // Check if max attempts (3) are reached if (isRetryNeeded == true && callCounter < grievanceAllocationRetryConfiguration) { // Increment the call counter for reattempt - grievanceDetails.setCallCounter(grievanceDetails.getCallCounter() + 1); + grievanceCallStatus.setCallCounter(grievanceCallStatus.getCallCounter() + 1); // Update the retryNeeded flag - grievanceDetails.setRetryNeeded(true); - updateCallCounter = grievanceDataRepo.updateCallCounter(grievanceDetails.getCallCounter(),grievanceDetails.getRetryNeeded(), grievanceCallRequest.getComplaintID(), + grievanceCallStatus.setRetryNeeded(true); + updateCallCounter = grievanceDataRepo.updateCallCounter(grievanceCallStatus.getCallCounter(),grievanceCallStatus.getRetryNeeded(), grievanceCallRequest.getComplaintID(), grievanceCallRequest.getBeneficiaryRegID(), grievanceCallRequest.getProviderServiceMapId(), grievanceCallRequest.getUserID()); // response = "Successfully closing call."; // Return success when reattempt logic is applied successfully. The grievance call needs to be retried, and a reattempt is performed. @@ -566,7 +562,7 @@ public String completeGrievanceCall(String request) throws Exception { } else if (callCounter == grievanceAllocationRetryConfiguration) { // Max attempts reached, no further reattempt updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, complaintID, userID, beneficiaryRegID, providerServiceMapId); - grievanceDetails.setRetryNeeded(false); + grievanceCallStatus.setRetryNeeded(false); response = "max_attempts_reached"; // Indicate that max attempts are reached From 9b8327129c40da8192d685ed54359b88193ffc35 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 27 Feb 2025 14:01:12 +0530 Subject: [PATCH 50/71] adding code rabbit suggested changes --- .../iemr/common/service/grievance/GrievanceDataSyncImpl.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) 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 c2965e56..2399ac2e 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -529,8 +529,7 @@ public String completeGrievanceCall(String request) throws Exception { String callType = callTypeObj.getCallType(); - // Logic for reattempt based on state and call type - // boolean isRetryNeeded = false; + // Logic for reattempt based on call group type and call type boolean isRetryNeeded = grievanceCallStatus.getRetryNeeded(); if (callGroupType.equals("Valid")) { From d7a3c6b7b595f3743121c99d3b2455435ef4bd76 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 27 Feb 2025 14:28:22 +0530 Subject: [PATCH 51/71] adding code rabbit fixes --- src/main/java/com/iemr/common/data/grievance/.gitignore | 1 + .../iemr/common/repository/grievance/GrievanceDataRepo.java | 3 ++- .../iemr/common/service/grievance/GrievanceDataSyncImpl.java | 4 ++-- 3 files changed, 5 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/iemr/common/data/grievance/.gitignore diff --git a/src/main/java/com/iemr/common/data/grievance/.gitignore b/src/main/java/com/iemr/common/data/grievance/.gitignore new file mode 100644 index 00000000..326e6610 --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/.gitignore @@ -0,0 +1 @@ +/GrievanceResponse.java 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 db261bf7..98594f27 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -100,11 +100,12 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso public List getCallCounter(@Param("complaintID") String complaintID); @Modifying - @Query("UPDATE GrievanceDetails g SET g.isCompleted = :isCompleted " + @Query("UPDATE GrievanceDetails g SET g.isCompleted = :isCompleted, g. 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, 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 2399ac2e..2aef2c2b 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -558,10 +558,10 @@ public String completeGrievanceCall(String request) throws Exception { else { response = "failure"; } - } else if (callCounter == grievanceAllocationRetryConfiguration) { + } else if (grievanceCallStatus.getCallCounter()== grievanceAllocationRetryConfiguration) { // Max attempts reached, no further reattempt - updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, complaintID, userID, beneficiaryRegID, providerServiceMapId); grievanceCallStatus.setRetryNeeded(false); + updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, grievanceCallStatus.getRetryNeeded(), complaintID, userID, beneficiaryRegID, providerServiceMapId); response = "max_attempts_reached"; // Indicate that max attempts are reached From fa2f43368865a19ec989fdce3426e1a77853c5d2 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 27 Feb 2025 14:36:24 +0530 Subject: [PATCH 52/71] adding code rabbit fixes --- .../iemr/common/service/grievance/GrievanceDataSyncImpl.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 2aef2c2b..be6022dd 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -549,7 +549,7 @@ public String completeGrievanceCall(String request) throws Exception { grievanceCallStatus.setCallCounter(grievanceCallStatus.getCallCounter() + 1); // Update the retryNeeded flag grievanceCallStatus.setRetryNeeded(true); - updateCallCounter = grievanceDataRepo.updateCallCounter(grievanceCallStatus.getCallCounter(),grievanceCallStatus.getRetryNeeded(), grievanceCallRequest.getComplaintID(), + updateCallCounter = grievanceDataRepo.updateCallCounter(callCounter, grievanceCallStatus.getRetryNeeded(), grievanceCallRequest.getComplaintID(), grievanceCallRequest.getBeneficiaryRegID(), grievanceCallRequest.getProviderServiceMapId(), grievanceCallRequest.getUserID()); // response = "Successfully closing call."; // Return success when reattempt logic is applied successfully. The grievance call needs to be retried, and a reattempt is performed. @@ -558,7 +558,7 @@ public String completeGrievanceCall(String request) throws Exception { else { response = "failure"; } - } else if (grievanceCallStatus.getCallCounter()== grievanceAllocationRetryConfiguration) { + } else if (callCounter == grievanceAllocationRetryConfiguration) { // Max attempts reached, no further reattempt grievanceCallStatus.setRetryNeeded(false); updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, grievanceCallStatus.getRetryNeeded(), complaintID, userID, beneficiaryRegID, providerServiceMapId); From ae716f91be629f90cc23669d7238a8a80973bed9 Mon Sep 17 00:00:00 2001 From: Srishti gupta <76839176+srishtigrp78@users.noreply.github.com> Date: Thu, 27 Feb 2025 14:37:32 +0530 Subject: [PATCH 53/71] Delete src/main/java/com/iemr/common/data/grievance/.gitignore --- src/main/java/com/iemr/common/data/grievance/.gitignore | 1 - 1 file changed, 1 deletion(-) delete mode 100644 src/main/java/com/iemr/common/data/grievance/.gitignore diff --git a/src/main/java/com/iemr/common/data/grievance/.gitignore b/src/main/java/com/iemr/common/data/grievance/.gitignore deleted file mode 100644 index 326e6610..00000000 --- a/src/main/java/com/iemr/common/data/grievance/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/GrievanceResponse.java From 84e0139c9e142f51d47c95f2a42d065fc942ea33 Mon Sep 17 00:00:00 2001 From: Srishti gupta <76839176+srishtigrp78@users.noreply.github.com> Date: Thu, 27 Feb 2025 14:46:04 +0530 Subject: [PATCH 54/71] AMM-1148 | Close call API including reattempt logic based on calltype (#164) * adding code for API to close call and make reattempts if needed * adding code changes suggested by code rabbit * adding code rabbit suggested changes * adding code rabbit fixes * adding code rabbit fixes * Delete src/main/java/com/iemr/common/data/grievance/.gitignore --------- Co-authored-by: SR20290919 --- src/main/environment/common_ci.properties | 2 +- src/main/environment/common_dev.properties | 2 +- .../environment/common_example.properties | 2 +- src/main/environment/common_test.properties | 2 +- src/main/environment/common_uat.properties | 2 +- .../grievance/GrievanceController.java | 30 +++++ .../data/grievance/GrievanceCallRequest.java | 17 +++ .../IEMRCalltypeRepositoryImplCustom.java | 4 +- .../grievance/GrievanceDataRepo.java | 32 ++++- .../service/grievance/GrievanceDataSync.java | 2 + .../grievance/GrievanceDataSyncImpl.java | 116 +++++++++++++++++- 11 files changed, 201 insertions(+), 10 deletions(-) create mode 100644 src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java 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 b422a240..d364338c 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -178,5 +178,35 @@ public String saveComplaintResolution( @Param(value = "{\"complaintID\":\" 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(); + } + + } 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..d485e739 --- /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/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java b/src/main/java/com/iemr/common/repository/callhandling/IEMRCalltypeRepositoryImplCustom.java index 8a5d3d29..92d767ca 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 callType, callGroupType 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 f69c2ecd..98594f27 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -72,7 +72,7 @@ int updateGrievanceAllocationStatus(@Param("grievanceId") Long grievanceId, public Set fetchUnallocatedGrievanceCount(); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy, " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.remarks = :remarks, g.modifiedBy = :modifiedBy " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.userID = :userID") @Transactional @@ -85,7 +85,7 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso @Param("userID") Integer userID); @Modifying - @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy, " + @Query("UPDATE GrievanceDetails g SET g.complaintResolution = :complaintResolution, g.modifiedBy = :modifiedBy " + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + " AND g.userID = :userID") @Transactional @@ -95,5 +95,33 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso @Param("beneficiaryRegID") Long beneficiaryRegID, @Param("providerServiceMapID") Integer providerServiceMapID, @Param("userID") Integer userID); + + @Query(" Select grievance.callCounter, grievance.retryNeeded FROM GrievanceDetails grievance where complaintID = :complaintID") + public List getCallCounter(@Param("complaintID") String complaintID); + + @Modifying + @Query("UPDATE GrievanceDetails g SET g.isCompleted = :isCompleted, g. 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); } 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..d0d32f2e 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -12,4 +12,6 @@ public interface GrievanceDataSync { public String fetchUnallocatedGrievanceCount(String preferredLanguage) 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..be6022dd 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; @@ -32,9 +33,12 @@ 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.everwell.EverwellDetails; +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 { @@ -62,16 +68,18 @@ public class GrievanceDataSyncImpl implements GrievanceDataSync { 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,6 +100,9 @@ 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; @@ -468,4 +479,105 @@ 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; + int callCounter = 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("Wrong Number") || 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; + } + } + + // Check if max attempts (3) are reached + if (isRetryNeeded == true && callCounter < grievanceAllocationRetryConfiguration) { + // Increment the call counter for reattempt + grievanceCallStatus.setCallCounter(grievanceCallStatus.getCallCounter() + 1); + // Update the retryNeeded flag + grievanceCallStatus.setRetryNeeded(true); + updateCallCounter = grievanceDataRepo.updateCallCounter(callCounter, grievanceCallStatus.getRetryNeeded(), grievanceCallRequest.getComplaintID(), + grievanceCallRequest.getBeneficiaryRegID(), grievanceCallRequest.getProviderServiceMapId(), + grievanceCallRequest.getUserID()); + // response = "Successfully closing call."; // 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"; + } + } else if (callCounter == grievanceAllocationRetryConfiguration) { + // Max attempts reached, no further reattempt + grievanceCallStatus.setRetryNeeded(false); + updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, grievanceCallStatus.getRetryNeeded(), 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) + } + } From 8055769844dd575340956a7d81c633cb5cfc73d0 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 27 Feb 2025 14:49:20 +0530 Subject: [PATCH 55/71] removing unused literal in repo class --- .../com/iemr/common/repository/grievance/GrievanceDataRepo.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 98594f27..f51083c2 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -100,7 +100,7 @@ int updateComplaintResolution(@Param("complaintResolution") String complaintReso public List getCallCounter(@Param("complaintID") String complaintID); @Modifying - @Query("UPDATE GrievanceDetails g SET g.isCompleted = :isCompleted, g. g.retryNeeded = :retryNeeded " + @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 From ef33bcd70b9b0552ea27df665680b95ef35c6c79 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 27 Feb 2025 16:11:30 +0530 Subject: [PATCH 56/71] changing logic of Close call after discussion --- .../data/grievance/GrievanceCallRequest.java | 2 +- .../IEMRCalltypeRepositoryImplCustom.java | 2 +- .../grievance/GrievanceDataSyncImpl.java | 21 +++++++++---------- 3 files changed, 12 insertions(+), 13 deletions(-) diff --git a/src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java b/src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java index d485e739..17178003 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceCallRequest.java @@ -11,7 +11,7 @@ public class GrievanceCallRequest { Long beneficiaryRegID; Integer callTypeID; Long benCallID; - Integer providerServiceMapId; + Integer providerServiceMapID; String createdBy; } 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 92d767ca..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,7 +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 callType, callGroupType from CallType " + @Query("select callGroupType, callType from CallType " + "where callTypeID = :callTypeID") Set getCallDetails(@Param("callTypeID") Integer callTypeID); } 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 be6022dd..cd3cd402 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -492,13 +492,12 @@ public String completeGrievanceCall(String request) throws Exception { Boolean isCompleted = grievanceCallRequest.getIsCompleted(); Long beneficiaryRegID = grievanceCallRequest.getBeneficiaryRegID(); Integer callTypeID = grievanceCallRequest.getCallTypeID(); - Integer providerServiceMapId = grievanceCallRequest.getProviderServiceMapId(); + Integer providerServiceMapID = grievanceCallRequest.getProviderServiceMapID(); CallType callTypeObj = new CallType(); String response = "failure"; int updateCount = 0; int updateCallCounter = 0; - int callCounter = 0; try { GrievanceDetails grievanceCallStatus = new GrievanceDetails(); @@ -544,24 +543,24 @@ public String completeGrievanceCall(String request) throws Exception { } // Check if max attempts (3) are reached - if (isRetryNeeded == true && callCounter < grievanceAllocationRetryConfiguration) { + if (isRetryNeeded == true && grievanceCallStatus.getCallCounter() < grievanceAllocationRetryConfiguration) { // Increment the call counter for reattempt grievanceCallStatus.setCallCounter(grievanceCallStatus.getCallCounter() + 1); // Update the retryNeeded flag - grievanceCallStatus.setRetryNeeded(true); - updateCallCounter = grievanceDataRepo.updateCallCounter(callCounter, grievanceCallStatus.getRetryNeeded(), grievanceCallRequest.getComplaintID(), - grievanceCallRequest.getBeneficiaryRegID(), grievanceCallRequest.getProviderServiceMapId(), + isRetryNeeded = true; + updateCallCounter = grievanceDataRepo.updateCallCounter(grievanceCallStatus.getCallCounter(), isRetryNeeded, grievanceCallRequest.getComplaintID(), + grievanceCallRequest.getBeneficiaryRegID(), grievanceCallRequest.getProviderServiceMapID(), grievanceCallRequest.getUserID()); - // response = "Successfully closing call."; // Return success when reattempt logic is applied successfully. The grievance call needs to be retried, and a reattempt is performed. + // 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"; + response = "failure in closing call"; } - } else if (callCounter == grievanceAllocationRetryConfiguration) { + } else if (grievanceCallStatus.getCallCounter()== grievanceAllocationRetryConfiguration) { // Max attempts reached, no further reattempt - grievanceCallStatus.setRetryNeeded(false); - updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, grievanceCallStatus.getRetryNeeded(), complaintID, userID, beneficiaryRegID, providerServiceMapId); + isRetryNeeded = false; + updateCount = grievanceDataRepo.updateCompletedStatusInCall(isCompleted, isRetryNeeded, complaintID, userID, beneficiaryRegID, providerServiceMapID); response = "max_attempts_reached"; // Indicate that max attempts are reached From 8fa08c4a3383f1cd86d435fd596af474460e4640 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Fri, 28 Feb 2025 15:37:05 +0530 Subject: [PATCH 57/71] adding changes related to invalid and wrong number call type --- .../common/service/grievance/GrievanceDataSyncImpl.java | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) 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 cd3cd402..74553bf7 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -533,7 +533,7 @@ public String completeGrievanceCall(String request) throws Exception { boolean isRetryNeeded = grievanceCallStatus.getRetryNeeded(); if (callGroupType.equals("Valid")) { // Conditions when no reattempt is needed - if (callType.equals("Valid") || callType.equals("Wrong Number") || callType.equals("Test Call")) { + 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")) { @@ -541,6 +541,11 @@ public String completeGrievanceCall(String request) throws Exception { 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) { @@ -548,6 +553,7 @@ public String completeGrievanceCall(String request) throws Exception { 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()); @@ -560,6 +566,7 @@ public String completeGrievanceCall(String request) throws Exception { } 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 From b2fff5741233809fb6ef6142e8e1631eb7a585b1 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 3 Mar 2025 10:20:42 +0530 Subject: [PATCH 58/71] adding code for API to push back grievance data to GR team --- .../grievance/GrievanceController.java | 14 +- .../data/grievance/GrievanceResponse.java | 70 ++++ .../BeneficiaryCallRepository.java | 6 + .../grievance/GrievanceDataRepo.java | 21 ++ .../grievance/GrievanceHandlingService.java | 2 + .../GrievanceHandlingServiceImpl.java | 301 +++++++++++++++++- 6 files changed, 412 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/iemr/common/data/grievance/GrievanceResponse.java 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 d364338c..0311fc2a 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -207,6 +207,18 @@ public String completeGrievanceCall( 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/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/repository/callhandling/BeneficiaryCallRepository.java b/src/main/java/com/iemr/common/repository/callhandling/BeneficiaryCallRepository.java index 60ec1b71..9e20b70d 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,11 @@ 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); + + @Query("SELECT b.callTypeID FROM BeneficiaryCall b WHERE b.beneficiaryRegID = :beneficiaryRegID") + Integer fetchCallTypeID(@Param("beneficiaryRegID") Long beneficiaryRegID); } 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 f51083c2..35f1e124 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; @@ -123,5 +124,25 @@ public int updateCallCounter(@Param("callCounter") Integer callCounter, @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); + + } 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 1eba9801..c1a19866 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java @@ -21,6 +21,8 @@ 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 094183db..14c9e2c7 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,19 @@ import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.iemr.common.data.callhandling.CallType; 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.callhandling.IEMRCalltypeRepositoryImplCustom; import com.iemr.common.repository.grievance.GrievanceDataRepo; import com.iemr.common.repository.grievance.GrievanceOutboundRepository; import com.iemr.common.utils.exception.IEMRException; @@ -37,11 +48,16 @@ public class GrievanceHandlingServiceImpl implements GrievanceHandlingService { private final GrievanceDataRepo grievanceDataRepo; private final GrievanceOutboundRepository grievanceOutboundRepo; + private final BeneficiaryCallRepository beneficiaryCallRepo; + private final IEMRCalltypeRepositoryImplCustom iEMRCalltypeRepositoryImplCustom; @Autowired - public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo, GrievanceOutboundRepository grievanceOutboundRepo) { + public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo, GrievanceOutboundRepository grievanceOutboundRepo, + BeneficiaryCallRepository beneficiaryCallRepo, IEMRCalltypeRepositoryImplCustom iEMRCalltypeRepositoryImplCustom) { this.grievanceDataRepo = grievanceDataRepo; this.grievanceOutboundRepo = grievanceOutboundRepo; + this.beneficiaryCallRepo = beneficiaryCallRepo; + this.iEMRCalltypeRepositoryImplCustom = iEMRCalltypeRepositoryImplCustom; } @Value("${grievanceAllocationRetryConfiguration}") @@ -386,5 +402,288 @@ public String saveComplaintResolution(String request) throws Exception { throw new Exception("Failed to update complaint resolution"); } } + + public List fetchGrievanceDetailsFromRequest(String request) { + ObjectMapper objectMapper = new ObjectMapper(); + JsonNode jsonNode = null; + + try { + // Parse the request JSON + jsonNode = objectMapper.readTree(request); + } catch (Exception e) { + logger.error("Error parsing request: " + e.getMessage(), e); + return null; + } + + // Extract parameters from the request + String state = jsonNode.has("State") ? jsonNode.get("State").asText() : null; + String complaintResolution = jsonNode.has("ComplaintResolution") ? jsonNode.get("ComplaintResolution").asText() : null; + String startDateStr = jsonNode.get("StartDate").asText(); + String endDateStr = jsonNode.get("EndDate").asText(); + + // Convert StartDate and EndDate to Date objects + Date startDate = parseDate(startDateStr); + Date endDate = parseDate(endDateStr); + + // Construct the query dynamically based on available parameters + return grievanceDataRepo.fetchGrievanceDetailsBasedOnParams(state, complaintResolution, startDate, endDate); + } + + + 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); + return null; + } +} + + + @Override + public String getGrievanceDetailsWithRemarks(String request) throws Exception { + ObjectMapper objectMapper = new ObjectMapper(); +// JsonNode jsonNode = null; +// +// try { +// // Parse the request JSON +// jsonNode = objectMapper.readTree(request); +// } catch (Exception e) { +// logger.error("Error parsing request: " + e.getMessage(), e); +// return null; +// } +// +// // Extract parameters from the request +// String state = jsonNode.has("State") ? jsonNode.get("State").asText() : null; +// String complaintResolution = jsonNode.has("ComplaintResolution") ? jsonNode.get("ComplaintResolution").asText() : null; +// String startDate = jsonNode.get("StartDate").asText(); +// String endDate = jsonNode.get("EndDate").asText(); + + + 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"); + + // 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) + remarks = fetchRemarksBasedOnConditions(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 + // ObjectMapper objectMapper = new ObjectMapper(); + return objectMapper.writeValueAsString(grievanceResponseList); + + } catch (Exception e) { + logger.error("Error while getting grievance details with remarks: " + e.getMessage(), e); + return "Error fetching grievance details with remarks: " + e.getMessage(); + } + } + +// @Override +// public String getGrievanceDetailsWithRemarks(String request) throws Exception { +// ObjectMapper objectMapper = new ObjectMapper(); +// JsonNode jsonNode = null; +// +// try { +// // Parse the request JSON +// jsonNode = objectMapper.readTree(request); +// } catch (Exception e) { +// logger.error("Error parsing request: " + e.getMessage(), e); +// return null; +// } +// +// // Extract parameters from the request +// String state = jsonNode.has("State") ? jsonNode.get("State").asText() : null; +// String complaintResolution = jsonNode.has("ComplaintResolution") ? jsonNode.get("ComplaintResolution").asText() : null; +// String startDate = jsonNode.get("StartDate").asText(); +// String endDate = jsonNode.get("EndDate").asText(); +// +// // Convert StartDate and EndDate to Date objects +// Date startDateStr = parseDate(startDate); +// Date endDateStr = parseDate(endDate); +// +// 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<>(); +// +// 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"); +// +// +// +// // 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) +// remarks = fetchRemarksBasedOnConditions(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 +// // ObjectMapper objectMapper = new ObjectMapper(); +// return objectMapper.writeValueAsString(grievanceResponseList); +// +// } catch (Exception e) { +// logger.error("Error while getting grievance details with remarks: " + e.getMessage(), e); +// return "Error fetching grievance details with remarks: " + e.getMessage(); +// } +// } + + private String fetchRemarksFromBenCallByComplaint(String complaintID) throws JSONException { + // 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"; + } + + +private String fetchRemarksBasedOnConditions(String complaintID) throws JSONException { + String remarks = ""; + // Query t_grievanceworklist to fetch the benRegId based on complaintID + List grievanceWorklist = grievanceDataRepo.fetchGrievanceWorklistByComplaintID(complaintID); + CallType callTypeObj = new CallType(); + + + if (grievanceWorklist != null && !grievanceWorklist.isEmpty()) { + GrievanceDetails grievance = grievanceWorklist.get(0); + Long beneficiaryRegID = grievance.getBeneficiaryRegID(); // Fetch the beneficiaryRegID from the grievance + + Integer benCall = beneficiaryCallRepo.fetchCallTypeID(beneficiaryRegID); + + // Fetching CallDetails using BenCallID and CallTypeID + Set callTypesArray = new HashSet(); + callTypesArray = iEMRCalltypeRepositoryImplCustom.getCallDetails(benCall); + 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(); + + // Scenario 1: if callGroupType is "invalid" and callType is "wrong number" + if ("invalid".equalsIgnoreCase(callGroupType) && "wrong number".equalsIgnoreCase(callType)) { + remarks = fetchRemarksFromBenCallByComplaint(complaintID); + } + // Scenario 2: if callCounter is 3 and callType is one of the specified types + else if (grievance.getCallCounter() == 3 && + (Arrays.asList("Switch off", "Not Reachable", "Silent Call", "Disconnected Call").contains(callType))) { + remarks = fetchRemarksFromBenCallByComplaint(complaintID);; + } + // Default case: fetch remarks from t_grievanceworklist based on complaintID + else { + remarks = fetchRemarksFromGrievanceWorklist(grievance.getComplaintID()); + } + + + } + return remarks; + } + } + From ce472ee3cf39e1bf917fffbe458051d839d38667 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 3 Mar 2025 10:57:52 +0530 Subject: [PATCH 59/71] removed unnecessary conditions --- .../BeneficiaryCallRepository.java | 3 - .../GrievanceHandlingServiceImpl.java | 134 +----------------- 2 files changed, 3 insertions(+), 134 deletions(-) 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 9e20b70d..e48e8f9d 100644 --- a/src/main/java/com/iemr/common/repository/callhandling/BeneficiaryCallRepository.java +++ b/src/main/java/com/iemr/common/repository/callhandling/BeneficiaryCallRepository.java @@ -194,7 +194,4 @@ public ArrayList getExistingBCByCallIDAndAgentID(@Param("callID @Query("SELECT b.remarks FROM BeneficiaryCall b WHERE b.beneficiaryRegID = :beneficiaryRegID") List fetchBenCallRemarks(@Param("beneficiaryRegID") Long beneficiaryRegID); - @Query("SELECT b.callTypeID FROM BeneficiaryCall b WHERE b.beneficiaryRegID = :beneficiaryRegID") - Integer fetchCallTypeID(@Param("beneficiaryRegID") Long beneficiaryRegID); - } 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 14c9e2c7..dcb2a68d 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -504,7 +504,8 @@ public String getGrievanceDetailsWithRemarks(String request) throws Exception { remarks = fetchRemarksFromGrievanceWorklist(grievance.getComplaintID()); } else { // Default: Fetch remarks based on the grievance's specific conditions (no specific resolution status) - remarks = fetchRemarksBasedOnConditions(grievance.getComplaintID()); + // remarks = fetchRemarksBasedOnConditions(grievance.getComplaintID()); + remarks = fetchRemarksFromBenCallByComplaint(grievance.getComplaintID()); } grievanceResponse.setRemarks(remarks); @@ -523,87 +524,7 @@ public String getGrievanceDetailsWithRemarks(String request) throws Exception { } } -// @Override -// public String getGrievanceDetailsWithRemarks(String request) throws Exception { -// ObjectMapper objectMapper = new ObjectMapper(); -// JsonNode jsonNode = null; -// -// try { -// // Parse the request JSON -// jsonNode = objectMapper.readTree(request); -// } catch (Exception e) { -// logger.error("Error parsing request: " + e.getMessage(), e); -// return null; -// } -// -// // Extract parameters from the request -// String state = jsonNode.has("State") ? jsonNode.get("State").asText() : null; -// String complaintResolution = jsonNode.has("ComplaintResolution") ? jsonNode.get("ComplaintResolution").asText() : null; -// String startDate = jsonNode.get("StartDate").asText(); -// String endDate = jsonNode.get("EndDate").asText(); -// -// // Convert StartDate and EndDate to Date objects -// Date startDateStr = parseDate(startDate); -// Date endDateStr = parseDate(endDate); -// -// 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<>(); -// -// 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"); -// -// -// -// // 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) -// remarks = fetchRemarksBasedOnConditions(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 -// // ObjectMapper objectMapper = new ObjectMapper(); -// return objectMapper.writeValueAsString(grievanceResponseList); -// -// } catch (Exception e) { -// logger.error("Error while getting grievance details with remarks: " + e.getMessage(), e); -// return "Error fetching grievance details with remarks: " + e.getMessage(); -// } -// } + private String fetchRemarksFromBenCallByComplaint(String complaintID) throws JSONException { // Query t_grievanceworklist to fetch the benRegId based on complaintID @@ -635,55 +556,6 @@ private String fetchRemarksFromGrievanceWorklist(String complaintID) throws JSON return "No remarks found in t_grievanceworklist"; } - -private String fetchRemarksBasedOnConditions(String complaintID) throws JSONException { - String remarks = ""; - // Query t_grievanceworklist to fetch the benRegId based on complaintID - List grievanceWorklist = grievanceDataRepo.fetchGrievanceWorklistByComplaintID(complaintID); - CallType callTypeObj = new CallType(); - - - if (grievanceWorklist != null && !grievanceWorklist.isEmpty()) { - GrievanceDetails grievance = grievanceWorklist.get(0); - Long beneficiaryRegID = grievance.getBeneficiaryRegID(); // Fetch the beneficiaryRegID from the grievance - - Integer benCall = beneficiaryCallRepo.fetchCallTypeID(beneficiaryRegID); - - // Fetching CallDetails using BenCallID and CallTypeID - Set callTypesArray = new HashSet(); - callTypesArray = iEMRCalltypeRepositoryImplCustom.getCallDetails(benCall); - 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(); - - // Scenario 1: if callGroupType is "invalid" and callType is "wrong number" - if ("invalid".equalsIgnoreCase(callGroupType) && "wrong number".equalsIgnoreCase(callType)) { - remarks = fetchRemarksFromBenCallByComplaint(complaintID); - } - // Scenario 2: if callCounter is 3 and callType is one of the specified types - else if (grievance.getCallCounter() == 3 && - (Arrays.asList("Switch off", "Not Reachable", "Silent Call", "Disconnected Call").contains(callType))) { - remarks = fetchRemarksFromBenCallByComplaint(complaintID);; - } - // Default case: fetch remarks from t_grievanceworklist based on complaintID - else { - remarks = fetchRemarksFromGrievanceWorklist(grievance.getComplaintID()); - } - - - } - return remarks; - } } From f5ca14c304c160b5f01234ca98ba0031a1a3ce73 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 3 Mar 2025 11:03:37 +0530 Subject: [PATCH 60/71] adding code rabbit changes --- .../GrievanceHandlingServiceImpl.java | 44 +------------------ 1 file changed, 2 insertions(+), 42 deletions(-) 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 dcb2a68d..63f1460d 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -403,31 +403,7 @@ public String saveComplaintResolution(String request) throws Exception { } } - public List fetchGrievanceDetailsFromRequest(String request) { - ObjectMapper objectMapper = new ObjectMapper(); - JsonNode jsonNode = null; - - try { - // Parse the request JSON - jsonNode = objectMapper.readTree(request); - } catch (Exception e) { - logger.error("Error parsing request: " + e.getMessage(), e); - return null; - } - - // Extract parameters from the request - String state = jsonNode.has("State") ? jsonNode.get("State").asText() : null; - String complaintResolution = jsonNode.has("ComplaintResolution") ? jsonNode.get("ComplaintResolution").asText() : null; - String startDateStr = jsonNode.get("StartDate").asText(); - String endDateStr = jsonNode.get("EndDate").asText(); - - // Convert StartDate and EndDate to Date objects - Date startDate = parseDate(startDateStr); - Date endDate = parseDate(endDateStr); - - // Construct the query dynamically based on available parameters - return grievanceDataRepo.fetchGrievanceDetailsBasedOnParams(state, complaintResolution, startDate, endDate); - } + private Date parseDate(String dateStr) { @@ -436,7 +412,7 @@ private Date parseDate(String dateStr) { return dateFormat.parse(dateStr); } catch (ParseException e) { logger.error("Error parsing date for grievance: " + dateStr, e); - return null; + throw new IllegalArgumentException("Invalid JSON format in request"); } } @@ -444,22 +420,6 @@ private Date parseDate(String dateStr) { @Override public String getGrievanceDetailsWithRemarks(String request) throws Exception { ObjectMapper objectMapper = new ObjectMapper(); -// JsonNode jsonNode = null; -// -// try { -// // Parse the request JSON -// jsonNode = objectMapper.readTree(request); -// } catch (Exception e) { -// logger.error("Error parsing request: " + e.getMessage(), e); -// return null; -// } -// -// // Extract parameters from the request -// String state = jsonNode.has("State") ? jsonNode.get("State").asText() : null; -// String complaintResolution = jsonNode.has("ComplaintResolution") ? jsonNode.get("ComplaintResolution").asText() : null; -// String startDate = jsonNode.get("StartDate").asText(); -// String endDate = jsonNode.get("EndDate").asText(); - try { // Parsing request to get the filter parameters (State, ComplaintResolution, StartDate, EndDate) From b95e4ccde6f00ba9082be02baf4e47c36f86546f Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 3 Mar 2025 11:09:14 +0530 Subject: [PATCH 61/71] adding code rabbit suggestions --- .../grievance/GrievanceHandlingServiceImpl.java | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) 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 63f1460d..59e82ea0 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -464,8 +464,14 @@ public String getGrievanceDetailsWithRemarks(String request) throws Exception { remarks = fetchRemarksFromGrievanceWorklist(grievance.getComplaintID()); } else { // Default: Fetch remarks based on the grievance's specific conditions (no specific resolution status) - // remarks = fetchRemarksBasedOnConditions(grievance.getComplaintID()); - remarks = fetchRemarksFromBenCallByComplaint(grievance.getComplaintID()); + String callRemarks = fetchRemarksFromBenCallByComplaint(grievance.getComplaintID()); + if(remarks != null && !remarks.startsWith("No remarks found")) { + remarks = callRemarks; + } + else { + remarks = fetchRemarksFromGrievanceWorklist(grievance.getComplaintID()); + + } } grievanceResponse.setRemarks(remarks); @@ -475,12 +481,11 @@ public String getGrievanceDetailsWithRemarks(String request) throws Exception { } // Convert the list of GrievanceResponse objects to JSON and return as a string - // ObjectMapper objectMapper = new ObjectMapper(); return objectMapper.writeValueAsString(grievanceResponseList); } catch (Exception e) { logger.error("Error while getting grievance details with remarks: " + e.getMessage(), e); - return "Error fetching grievance details with remarks: " + e.getMessage(); + throw new Exception("Error processing grievance request"); } } From 50afdf96c4eab2f1ae789263ae3d7e0aae9dc6e7 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 3 Mar 2025 11:12:04 +0530 Subject: [PATCH 62/71] adding required null checks --- .../common/service/grievance/GrievanceHandlingServiceImpl.java | 3 +++ 1 file changed, 3 insertions(+) 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 59e82ea0..85e0fa4e 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -429,6 +429,9 @@ public String getGrievanceDetailsWithRemarks(String request) throws Exception { 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); From e1465d92eca6fcffd5e98489b5ee17ed5c73ee2c Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 3 Mar 2025 11:16:48 +0530 Subject: [PATCH 63/71] adding code rabbit suggested changes --- .../service/grievance/GrievanceHandlingServiceImpl.java | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) 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 85e0fa4e..3d48927e 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -21,9 +21,7 @@ import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; -import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; -import com.iemr.common.data.callhandling.CallType; import com.iemr.common.data.grievance.GetGrievanceWorklistRequest; import com.iemr.common.data.grievance.GrievanceAllocationRequest; import com.iemr.common.data.grievance.GrievanceDetails; @@ -33,7 +31,6 @@ 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.callhandling.IEMRCalltypeRepositoryImplCustom; import com.iemr.common.repository.grievance.GrievanceDataRepo; import com.iemr.common.repository.grievance.GrievanceOutboundRepository; import com.iemr.common.utils.exception.IEMRException; @@ -49,15 +46,13 @@ public class GrievanceHandlingServiceImpl implements GrievanceHandlingService { private final GrievanceDataRepo grievanceDataRepo; private final GrievanceOutboundRepository grievanceOutboundRepo; private final BeneficiaryCallRepository beneficiaryCallRepo; - private final IEMRCalltypeRepositoryImplCustom iEMRCalltypeRepositoryImplCustom; @Autowired public GrievanceHandlingServiceImpl(GrievanceDataRepo grievanceDataRepo, GrievanceOutboundRepository grievanceOutboundRepo, - BeneficiaryCallRepository beneficiaryCallRepo, IEMRCalltypeRepositoryImplCustom iEMRCalltypeRepositoryImplCustom) { + BeneficiaryCallRepository beneficiaryCallRepo) { this.grievanceDataRepo = grievanceDataRepo; this.grievanceOutboundRepo = grievanceOutboundRepo; this.beneficiaryCallRepo = beneficiaryCallRepo; - this.iEMRCalltypeRepositoryImplCustom = iEMRCalltypeRepositoryImplCustom; } @Value("${grievanceAllocationRetryConfiguration}") @@ -412,7 +407,7 @@ private Date parseDate(String dateStr) { return dateFormat.parse(dateStr); } catch (ParseException e) { logger.error("Error parsing date for grievance: " + dateStr, e); - throw new IllegalArgumentException("Invalid JSON format in request"); + throw new IllegalArgumentException("Invalid date format in request:"+ dateStr); } } From 057734cca17fd2b0b9265d4c50240518ff008e65 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 3 Mar 2025 11:19:10 +0530 Subject: [PATCH 64/71] removing unnecessary Exception --- .../common/service/grievance/GrievanceHandlingServiceImpl.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 3d48927e..bc77cae2 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -489,7 +489,7 @@ public String getGrievanceDetailsWithRemarks(String request) throws Exception { - private String fetchRemarksFromBenCallByComplaint(String complaintID) throws JSONException { + private String fetchRemarksFromBenCallByComplaint(String complaintID) throws Exception { // Query t_grievanceworklist to fetch the benRegId based on complaintID List grievanceWorklist = grievanceDataRepo.fetchGrievanceWorklistByComplaintID(complaintID); From 4933750360f258d09258d5db1a6300a1bab74a82 Mon Sep 17 00:00:00 2001 From: Srishti gupta <76839176+srishtigrp78@users.noreply.github.com> Date: Tue, 4 Mar 2025 12:06:42 +0530 Subject: [PATCH 65/71] AMM-1149 | API to push back Grievance data to the GR team (#166) * adding code for API to push back grievance data to GR team * removed unnecessary conditions * adding code rabbit changes * adding code rabbit suggestions * adding required null checks * adding code rabbit suggested changes * removing unnecessary Exception --------- Co-authored-by: SR20290919 --- .../grievance/GrievanceController.java | 14 +- .../data/grievance/GrievanceResponse.java | 70 +++++++++ .../BeneficiaryCallRepository.java | 3 + .../grievance/GrievanceDataRepo.java | 21 +++ .../grievance/GrievanceHandlingService.java | 2 + .../GrievanceHandlingServiceImpl.java | 136 +++++++++++++++++- 6 files changed, 244 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/iemr/common/data/grievance/GrievanceResponse.java 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 d364338c..0311fc2a 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -207,6 +207,18 @@ public String completeGrievanceCall( 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/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/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/grievance/GrievanceDataRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java index f51083c2..35f1e124 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; @@ -123,5 +124,25 @@ public int updateCallCounter(@Param("callCounter") Integer callCounter, @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); + + } 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 1eba9801..c1a19866 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingService.java @@ -21,6 +21,8 @@ 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 094183db..bc77cae2 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}") @@ -386,5 +397,128 @@ public String saveComplaintResolution(String request) throws Exception { 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"; + } + + } + From 41c3f09aa0175efb39f9c78099e41bcce7127cbf Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Tue, 4 Mar 2025 16:40:24 +0530 Subject: [PATCH 66/71] adding code changes for variable name change of lang --- .../iemr/common/service/grievance/GrievanceDataSyncImpl.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 74553bf7..dd4d6baa 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -61,8 +61,8 @@ 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; From c88ad773ba6d0f2a9302849a9ad43a0ead9bc9af Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Thu, 6 Mar 2025 16:35:37 +0530 Subject: [PATCH 67/71] adding code changes for grievance issues --- .../grievance/GrievanceController.java | 2 +- .../grievance/GrievanceAllocationRequest.java | 8 ++--- .../data/grievance/GrievanceDetails.java | 7 +---- .../grievance/GrievanceDataRepo.java | 30 ++++++++++++------- .../service/grievance/GrievanceDataSync.java | 4 ++- .../grievance/GrievanceDataSyncImpl.java | 7 ++--- .../GrievanceHandlingServiceImpl.java | 27 +++++++++-------- 7 files changed, 46 insertions(+), 39 deletions(-) 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 0311fc2a..8ac8a8d4 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); 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/GrievanceDetails.java b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java index 910ab886..809a4e5d 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -76,10 +76,6 @@ public class GrievanceDetails { @Column(name = "State") private String state; - @Expose - @Column(name = "Agentid") - private String agentid; - @Expose @Column(name = "userid") private Integer userID; @@ -169,7 +165,7 @@ 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, String state, Integer userid, Boolean isAllocated, Boolean retryNeeded, Boolean isRegistered, Integer callCounter, Integer preferredLanguageId, String preferredLanguage, String complaintResolution, String remarks, Boolean deleted, Character processed, String createdBy, Timestamp createdDate, String modifiedBy, Timestamp lastModDate, Integer vanSerialNo, Integer vanID, String vehicalNo, @@ -186,7 +182,6 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long this.primaryNumber = primaryNumber; this.severety = severety; this.state = state; - this.agentid = agentID; this.userID = userid; this.isAllocated = isAllocated; this.retryNeeded = retryNeeded; 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 35f1e124..75a77d5e 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -60,44 +60,52 @@ List findGrievancesByUserAndLanguage(@Param("userID") Integer @Modifying @Transactional - @Query("UPDATE GrievanceDetails g SET g.userID = NULL WHERE g.grievanceId = :grievanceId AND g.userID = :userID") - int unassignGrievance(@Param("grievanceId") Long grievanceId, @Param("userID") Integer userID); + @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 " - + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + @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 " - + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + @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 complaintID = :complaintID") + @Query(" Select grievance.callCounter, grievance.retryNeeded FROM GrievanceDetails grievance where grievance.complaintID = :complaintID") public List getCallCounter(@Param("complaintID") String complaintID); @Modifying 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 d0d32f2e..9cb4537d 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; @@ -10,7 +11,8 @@ public interface GrievanceDataSync { public List> dataSyncToGrievance(); - public String fetchUnallocatedGrievanceCount(String preferredLanguage) throws IEMRException, JSONException; + 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 dd4d6baa..0d4e810c 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -251,7 +251,6 @@ public List> dataSyncToGrievance() { } // Setting remaining grievance properties (similar to the existing code) - grievance.setAgentid(grievance.getAgentid()); grievance.setDeleted(grievance.getDeleted()); grievance.setCreatedBy(registeringUser); grievance.setProcessed('N'); @@ -294,7 +293,6 @@ public List> dataSyncToGrievance() { 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()); @@ -413,11 +411,12 @@ private void generateGrievanceAuthToken() { } } - public String fetchUnallocatedGrievanceCount(String preferredLanguage) throws IEMRException, JSONException { + 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(); 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 bc77cae2..6db4b497 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -73,7 +73,7 @@ public String allocateGrievances(String request) throws Exception { // 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."); @@ -85,7 +85,7 @@ public String allocateGrievances(String request) throws Exception { // Step 4: Get the allocation parameters from the request int totalAllocated = 0; int userIndex = 0; - List userIds = allocationRequest.getUserID(); + List userIds = allocationRequest.getTouserID(); int allocateNo = allocationRequest.getAllocateNo(); // Number of grievances to allocate per user for (int i = 0; i < grievances.size(); i++) { @@ -230,22 +230,22 @@ 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.getUserID()); + 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(), + 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(), + 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(), + logger.error("Failed to unassign grievance gwid {} from user ID {}", grievance.getGwid(), moveToBinRequest.getUserID()); } } @@ -368,6 +368,9 @@ public String saveComplaintResolution(String request) throws Exception { 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(); @@ -376,17 +379,17 @@ public String saveComplaintResolution(String request) throws Exception { 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, complaintID, + 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, complaintID, + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, modifiedBy, benCallID, complaintID, beneficiaryRegID, providerServiceMapID, userID); logger.debug("updated complaint resolution with remarks for complaint id: {}", complaintID); From d33ac0bd6df2d89d7de8a39bc2ff7240e4e56de3 Mon Sep 17 00:00:00 2001 From: Srishti gupta <76839176+srishtigrp78@users.noreply.github.com> Date: Thu, 6 Mar 2025 16:50:39 +0530 Subject: [PATCH 68/71] adding code changes for grievance issues (#168) Co-authored-by: SR20290919 --- .../grievance/GrievanceController.java | 2 +- .../grievance/GrievanceAllocationRequest.java | 8 ++--- .../data/grievance/GrievanceDetails.java | 7 +---- .../grievance/GrievanceDataRepo.java | 30 ++++++++++++------- .../service/grievance/GrievanceDataSync.java | 4 ++- .../grievance/GrievanceDataSyncImpl.java | 7 ++--- .../GrievanceHandlingServiceImpl.java | 27 +++++++++-------- 7 files changed, 46 insertions(+), 39 deletions(-) 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 0311fc2a..8ac8a8d4 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); 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/GrievanceDetails.java b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java index 910ab886..809a4e5d 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -76,10 +76,6 @@ public class GrievanceDetails { @Column(name = "State") private String state; - @Expose - @Column(name = "Agentid") - private String agentid; - @Expose @Column(name = "userid") private Integer userID; @@ -169,7 +165,7 @@ 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, String state, Integer userid, Boolean isAllocated, Boolean retryNeeded, Boolean isRegistered, Integer callCounter, Integer preferredLanguageId, String preferredLanguage, String complaintResolution, String remarks, Boolean deleted, Character processed, String createdBy, Timestamp createdDate, String modifiedBy, Timestamp lastModDate, Integer vanSerialNo, Integer vanID, String vehicalNo, @@ -186,7 +182,6 @@ public GrievanceDetails(Long gwid, Long grievanceId, Long beneficiaryRegID, Long this.primaryNumber = primaryNumber; this.severety = severety; this.state = state; - this.agentid = agentID; this.userID = userid; this.isAllocated = isAllocated; this.retryNeeded = retryNeeded; 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 35f1e124..75a77d5e 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -60,44 +60,52 @@ List findGrievancesByUserAndLanguage(@Param("userID") Integer @Modifying @Transactional - @Query("UPDATE GrievanceDetails g SET g.userID = NULL WHERE g.grievanceId = :grievanceId AND g.userID = :userID") - int unassignGrievance(@Param("grievanceId") Long grievanceId, @Param("userID") Integer userID); + @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 " - + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + @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 " - + "WHERE g.complaintID = :complaintID AND g.beneficiaryRegID = :beneficiaryRegID AND g.providerServiceMapID = :providerServiceMapID" + @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 complaintID = :complaintID") + @Query(" Select grievance.callCounter, grievance.retryNeeded FROM GrievanceDetails grievance where grievance.complaintID = :complaintID") public List getCallCounter(@Param("complaintID") String complaintID); @Modifying 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 d0d32f2e..9cb4537d 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; @@ -10,7 +11,8 @@ public interface GrievanceDataSync { public List> dataSyncToGrievance(); - public String fetchUnallocatedGrievanceCount(String preferredLanguage) throws IEMRException, JSONException; + 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 dd4d6baa..0d4e810c 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -251,7 +251,6 @@ public List> dataSyncToGrievance() { } // Setting remaining grievance properties (similar to the existing code) - grievance.setAgentid(grievance.getAgentid()); grievance.setDeleted(grievance.getDeleted()); grievance.setCreatedBy(registeringUser); grievance.setProcessed('N'); @@ -294,7 +293,6 @@ public List> dataSyncToGrievance() { 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()); @@ -413,11 +411,12 @@ private void generateGrievanceAuthToken() { } } - public String fetchUnallocatedGrievanceCount(String preferredLanguage) throws IEMRException, JSONException { + 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(); 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 bc77cae2..6db4b497 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -73,7 +73,7 @@ public String allocateGrievances(String request) throws Exception { // 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."); @@ -85,7 +85,7 @@ public String allocateGrievances(String request) throws Exception { // Step 4: Get the allocation parameters from the request int totalAllocated = 0; int userIndex = 0; - List userIds = allocationRequest.getUserID(); + List userIds = allocationRequest.getTouserID(); int allocateNo = allocationRequest.getAllocateNo(); // Number of grievances to allocate per user for (int i = 0; i < grievances.size(); i++) { @@ -230,22 +230,22 @@ 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.getUserID()); + 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(), + 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(), + 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(), + logger.error("Failed to unassign grievance gwid {} from user ID {}", grievance.getGwid(), moveToBinRequest.getUserID()); } } @@ -368,6 +368,9 @@ public String saveComplaintResolution(String request) throws Exception { 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(); @@ -376,17 +379,17 @@ public String saveComplaintResolution(String request) throws Exception { 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, complaintID, + 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, complaintID, + updateCount = grievanceDataRepo.updateComplaintResolution(complaintResolution, remarks, modifiedBy, benCallID, complaintID, beneficiaryRegID, providerServiceMapID, userID); logger.debug("updated complaint resolution with remarks for complaint id: {}", complaintID); From 474d9ecf2db1a7dcd6bd6b40b647700c127d0804 Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 10 Mar 2025 14:59:48 +0530 Subject: [PATCH 69/71] adding fixes related to grievance related APIs --- .../grievance/GrievanceController.java | 19 +- .../dto/grivance/GrievanceTransactionDTO.java | 7 +- .../dto/grivance/GrievanceWorklistDTO.java | 6 +- .../GrievanceOutboundRepository.java | 13 +- .../GrievanceHandlingServiceImpl.java | 186 ++++++++++-------- 5 files changed, 136 insertions(+), 95 deletions(-) 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 8ac8a8d4..71acde86 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -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,11 +154,16 @@ 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.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse); } - return ResponseEntity.ok(response); + return ResponseEntity.ok(responseMap); } 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/grievance/GrievanceOutboundRepository.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java index 88c50d66..4cf62e82 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java @@ -3,6 +3,7 @@ import java.util.List; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; import org.springframework.data.jpa.repository.query.Procedure; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; @@ -15,9 +16,13 @@ @Repository public interface GrievanceOutboundRepository extends JpaRepository { - @Transactional - @Procedure(procedureName = "Pr_Grievanceworklist") - List getGrievanceWorklistData(@Param("providerServiceMapId") Integer providerServiceMapId, - @Param("userId") Integer userId); +// @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/GrievanceHandlingServiceImpl.java b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java index 6db4b497..b170a474 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -61,55 +61,60 @@ 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 2: Fetch grievances based on the start date, end date range, and - // language - List grievances = grievanceDataRepo.findGrievancesInDateRangeAndLanguage( - allocationRequest.getStartDate(), allocationRequest.getEndDate(), - allocationRequest.getLanguage()); - - if (grievances.isEmpty()) { - throw new Exception("No grievances found in the given date range and language."); - } + // Step 1: Parse the request string into the appropriate GrievanceAllocationRequest object + GrievanceAllocationRequest allocationRequest = InputMapper.gson().fromJson(request, GrievanceAllocationRequest.class); - // Step 3: Sort grievances in ascending order based on creation date - grievances.sort(Comparator.comparing(GrievanceDetails::getCreatedDate)); + // Step 2: Fetch grievances based on the start date, end date range, and language + List grievances = grievanceDataRepo.findGrievancesInDateRangeAndLanguage( + allocationRequest.getStartDate(), allocationRequest.getEndDate(), + allocationRequest.getLanguage()); - // Step 4: Get the allocation parameters from the request - int totalAllocated = 0; - int userIndex = 0; - List userIds = allocationRequest.getTouserID(); - int allocateNo = allocationRequest.getAllocateNo(); // Number of grievances to allocate per user + if (grievances.isEmpty()) { + throw new Exception("No grievances found in the given date range and language."); + } - 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); @@ -146,57 +151,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); + } - // Step 6: Return a message with the total number of grievances reallocated - return "Successfully reallocated " + totalReallocated + " grievances to users."; + 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 + " grievance to user."; } + + @Override public String moveToBin(String request) throws Exception { // Step 1: Parse the request string into the appropriate MoveToBinRequest object @@ -284,22 +293,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 = "N/A"; // Default value for age if it's not available + if (row[25] != null) { + Double age = (Double) 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 @@ -312,14 +329,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 From c31f0b44641067b71dbe714edb87452cda04733f Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Mon, 10 Mar 2025 15:22:01 +0530 Subject: [PATCH 70/71] fixing code rabbit issues --- .../common/controller/grievance/GrievanceController.java | 1 - .../repository/grievance/GrievanceOutboundRepository.java | 6 ------ 2 files changed, 7 deletions(-) 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 71acde86..a4e3212c 100644 --- a/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java +++ b/src/main/java/com/iemr/common/controller/grievance/GrievanceController.java @@ -159,7 +159,6 @@ public ResponseEntity> getGrievanceOutboundWorklist(@Param(v responseMap.put("statusCode", HttpStatus.INTERNAL_SERVER_ERROR.value()); responseMap.put("errorMessage", e.getMessage()); responseMap.put("status", "Error"); - // return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse); } 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 4cf62e82..88c8dfa9 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceOutboundRepository.java @@ -4,22 +4,16 @@ import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; -import org.springframework.data.jpa.repository.query.Procedure; 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, From c029dd6e24f20dc6990fd367d85e3f474933c34d Mon Sep 17 00:00:00 2001 From: SR20290919 Date: Wed, 12 Mar 2025 21:07:57 +0530 Subject: [PATCH 71/71] adding code fixes related to scheduler --- .../data/grievance/GrievanceDetails.java | 9 +- .../data/grievance/GrievanceTransaction.java | 28 +- .../grievance/GrievanceDataRepo.java | 11 +- .../GrievanceFetchBenDetailsRepo.java | 2 +- .../service/grievance/GrievanceDataSync.java | 5 +- .../grievance/GrievanceDataSyncImpl.java | 344 ++++++++++++------ .../GrievanceHandlingServiceImpl.java | 4 +- 7 files changed, 264 insertions(+), 139 deletions(-) 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 809a4e5d..17019b54 100644 --- a/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -71,7 +71,7 @@ public class GrievanceDetails { @Expose @Column(name = "Level") - private String level; + private Integer level; @Expose @Column(name = "State") private String state; @@ -136,7 +136,7 @@ public class GrievanceDetails { @Expose @Column(name = "VanSerialNo") - private Integer vanSerialNo; + private Long vanSerialNo; @Expose @Column(name = "VanID") private Integer vanID; @@ -165,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, 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, String complaintResolution, String remarks, Boolean deleted, Character processed, String createdBy, Timestamp createdDate, - String modifiedBy, Timestamp lastModDate, Integer vanSerialNo, Integer vanID, String vehicalNo, + String modifiedBy, Timestamp lastModDate, Long vanSerialNo, Integer vanID, String vehicalNo, Integer parkingPlaceID, String syncedBy, Timestamp syncedDate, Boolean isCompleted) { super(); this.gwid = gwid; @@ -181,6 +181,7 @@ 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.userID = userid; this.isAllocated = isAllocated; 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/repository/grievance/GrievanceDataRepo.java b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java index 75a77d5e..7d8f39b7 100644 --- a/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceDataRepo.java @@ -33,9 +33,15 @@ List findGrievancesInDateRangeAndLanguage(@Param("startDate") public int allocateGrievance(@Param("grievanceId") Long grievanceId, @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.userID = :userID " + "and grievance.deleted = false " @@ -151,6 +157,9 @@ List fetchGrievanceDetailsBasedOnParams( @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/service/grievance/GrievanceDataSync.java b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java index 9cb4537d..f0798533 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSync.java @@ -9,7 +9,10 @@ import com.iemr.common.utils.exception.IEMRException; public interface GrievanceDataSync { - public List> dataSyncToGrievance(); +// public List> dataSyncToGrievance(); + + public String dataSyncToGrievance(); + public String fetchUnallocatedGrievanceCount(String preferredLanguage, Timestamp filterStartDate, Timestamp filterEndDate, Integer providerServiceMapID) throws IEMRException, JSONException; 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 0d4e810c..113a6c7c 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -30,11 +30,11 @@ 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.everwell.EverwellDetails; import com.iemr.common.data.grievance.GrievanceCallRequest; import com.iemr.common.data.grievance.GrievanceDetails; import com.iemr.common.data.grievance.GrievanceTransaction; @@ -106,12 +106,25 @@ public GrievanceDataSyncImpl(GrievanceDataRepo grievanceDataRepo, GrievanceTrans 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) { @@ -129,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()); @@ -145,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("\\/", "/"); @@ -174,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()); @@ -242,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]); @@ -250,60 +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.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("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 @@ -317,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); @@ -332,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() { @@ -368,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"); @@ -392,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 { @@ -411,6 +519,7 @@ private void generateGrievanceAuthToken() { } } + @Override public String fetchUnallocatedGrievanceCount(String preferredLanguage, Timestamp filterStartDate, Timestamp filterEndDate, Integer providerServiceMapID) throws IEMRException, JSONException { logger.debug("Request received for fetchUnallocatedGrievanceCount"); @@ -480,7 +589,6 @@ public String fetchUnallocatedGrievanceCount(String preferredLanguage, Timestamp } - @Override @Transactional public String completeGrievanceCall(String request) throws Exception { @@ -585,4 +693,6 @@ public String completeGrievanceCall(String request) throws Exception { return response; // Return the response (either success or error message) } + + } 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 7e95b792..b930bce3 100644 --- a/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceHandlingServiceImpl.java @@ -301,9 +301,9 @@ public List getFormattedGrievanceData(String request) thro } // Handle age conversion from Double to "x years" format - String ageFormatted = "N/A"; // Default value for age if it's not available + String ageFormatted = null; // Default value for age if it's not available if (row[25] != null) { - Double age = (Double) row[25]; + Long age = (Long) row[25]; ageFormatted = age.intValue() + " years"; // Convert the age to integer and append " years" }