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..ac359f40 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); @@ -169,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()); @@ -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..8843738c --- /dev/null +++ b/src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java @@ -0,0 +1,38 @@ +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()); + + + private final GrievanceDataSync grievanceDataSync; + + @Autowired + 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()); + 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..160d0d83 --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceDetails.java @@ -0,0 +1,449 @@ +package com.iemr.common.data.grievance; + +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 jakarta.validation.constraints.NotBlank; +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") + @NotBlank(message = "Severety is required") + 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; + + @OneToMany(mappedBy = "grievanceDetails", cascade = CascadeType.ALL, fetch = FetchType.LAZY) + @JsonManagedReference + 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..b559339f --- /dev/null +++ b/src/main/java/com/iemr/common/data/grievance/GrievanceTransaction.java @@ -0,0 +1,245 @@ +package com.iemr.common.data.grievance; + + +import javax.persistence.*; + +import com.google.gson.annotations.Expose; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; +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 + @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) + @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; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "gwid", insertable = false, updatable = false) + private GrievanceDetails grievanceDetails; + + // 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 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 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..2d8c6c41 --- /dev/null +++ b/src/main/java/com/iemr/common/repository/grievance/GrievanceFetchBenDetailsRepo.java @@ -0,0 +1,21 @@ +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 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/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..b6c7e8f6 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.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..c13a92a0 --- /dev/null +++ b/src/main/java/com/iemr/common/service/grievance/GrievanceDataSyncImpl.java @@ -0,0 +1,375 @@ +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 implements GrievanceDataSync { + Logger logger = LoggerFactory.getLogger(this.getClass().getName()); + + 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 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; + private final LocationStateRepository locationStateRepository; + + // Constructor-based injection + @Autowired + 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; + + @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 String GRIEVANCE_AUTH_TOKEN; + private Long GRIEVANCE_TOKEN_EXP; + + + public List> dataSyncToGrievance() { + + int count = 0; + String registeringUser = ""; + 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_HEADER, USER_AGENT_VALUE); + headers.add("AUTHORIZATION", GRIEVANCE_AUTH_TOKEN); + + Date date = new Date(); + java.sql.Date sqlDate = new java.sql.Date(date.getTime()); + Calendar calendar = Calendar.getInstance(); + calendar.setTime(sqlDate); + calendar.add(Calendar.DATE, -Integer.parseInt(grievanceDataSyncDuration)); + + // 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(STATUS_CODE) && obj.getInt(STATUS_CODE) == 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"); + + 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); + + + ////////////////////// + // 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(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()); + 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("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); + } + + combinedData.put("transaction", transactions); + combinedData.put("severity", grievance.getSeverety()); + combinedData.put("state", grievance.getState()); + combinedData.put("agentId", grievance.getAgentId()); + combinedData.put("deleted", grievance.getDeleted()); + combinedData.put("createdBy", grievance.getCreatedBy()); + combinedData.put("createdDate", grievance.getCreatedDate()); + combinedData.put("lastModDate", grievance.getLastModDate()); + combinedData.put("isCompleted", grievance.getIsCompleted()); + + combinedData.put("retryNeeded", grievance.getRetryNeeded()); + combinedData.put("callCounter", grievance.getCallCounter()); + + responseData.add(combinedData); + } + + + // Return the combined response as required + + } 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(Long grievanceId) { + List transactionDetailsList = new ArrayList<>(); + try { + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); + headers.add(USER_AGENT_HEADER, USER_AGENT_VALUE); + headers.add("AUTHORIZATION", GRIEVANCE_AUTH_TOKEN); + + HttpEntity request = new HttpEntity(headers); + RestTemplate restTemplate = new RestTemplate(); + + 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(STATUS_CODE) && obj.getInt(STATUS_CODE) == 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 grievanceId " + grievanceId, e); + } + return transactionDetailsList; + } + + private void generateGrievanceAuthToken() { + + 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_HEADER, USER_AGENT_VALUE); + + 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"); + + + 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) { + try { + List> savedGrievanceData = dataSyncToGrievance(); + if (savedGrievanceData != null) + break; + else { + count--; + + if (count > 0) { + Thread.sleep(5000); + } + } + + } catch(InterruptedException e) { + Thread.currentThread().interrupt(); + break; + } + } + } + } + +}