538 lines
22 KiB
Java
538 lines
22 KiB
Java
package com.billpaymentservice.bbps.util;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
import org.springframework.stereotype.Component;
|
|
|
|
import com.billpaymentservice.bbps.dto.AmountOptionDTO;
|
|
import com.billpaymentservice.bbps.dto.BillerIconDTO;
|
|
import com.billpaymentservice.bbps.dto.ComplainDetailsDto;
|
|
import com.billpaymentservice.bbps.dto.ComplaintHistoryDTO;
|
|
import com.billpaymentservice.bbps.dto.CustomerParamGroupsDTO;
|
|
import com.billpaymentservice.bbps.dto.GroupDTO;
|
|
import com.billpaymentservice.bbps.dto.MasterCategoryBillerResponse;
|
|
import com.billpaymentservice.bbps.dto.PlanDTO;
|
|
import com.billpaymentservice.bbps.dto.response.AmountOptionsResponse;
|
|
import com.billpaymentservice.bbps.dto.response.ComplaintHistoryStatusResponse;
|
|
import com.billpaymentservice.bbps.dto.response.ComplaintStatusResponse;
|
|
import com.billpaymentservice.bbps.dto.response.PlanResponse;
|
|
import com.billpaymentservice.bbps.entites.AdditionalInfoPlans;
|
|
import com.billpaymentservice.bbps.entites.AmountOptionByBillerId;
|
|
import com.billpaymentservice.bbps.entites.AmountOptionDetails;
|
|
import com.billpaymentservice.bbps.entites.BillerCategoryIcon;
|
|
import com.billpaymentservice.bbps.entites.BillerCategoryWise;
|
|
import com.billpaymentservice.bbps.entites.CategoryResponseList;
|
|
import com.billpaymentservice.bbps.entites.ComplainStatus;
|
|
import com.billpaymentservice.bbps.entites.ComplaintHistory;
|
|
import com.billpaymentservice.bbps.entites.CustomerParamGroupById;
|
|
import com.billpaymentservice.bbps.entites.GroupParam;
|
|
import com.billpaymentservice.bbps.entites.Plan;
|
|
import com.billpaymentservice.bbps.entites.PlanCategorySubType;
|
|
import com.billpaymentservice.bbps.entites.PlanResponses;
|
|
import com.billpaymentservice.bbps.entites.PlansList;
|
|
import com.billpaymentservice.bbps.entites.ReOpenComplain;
|
|
import com.billpaymentservice.bbps.repository.AmountOptionByBillerIdRepository;
|
|
import com.billpaymentservice.bbps.repository.BillerCategoryWiseRepository;
|
|
import com.billpaymentservice.bbps.repository.CategoryResponseListRepository;
|
|
import com.billpaymentservice.bbps.repository.ComplaintHistoryRepository;
|
|
import com.billpaymentservice.bbps.repository.ComplaintStatusRepository;
|
|
import com.billpaymentservice.bbps.repository.CustomerParamGroupByBillerIdRepository;
|
|
import com.billpaymentservice.bbps.repository.FetchBillValidateRepository;
|
|
import com.billpaymentservice.bbps.repository.PlanResponseRepository;
|
|
import com.billpaymentservice.bbps.repository.ReOpenComplaintRepository;
|
|
import com.billpaymentservice.bbps.serviceImpl.AgentServiceImpl;
|
|
|
|
@Component
|
|
public class BillerMapperHelper {
|
|
|
|
private static final Logger LOGGER = LoggerFactory.getLogger(BillerMapperHelper.class);
|
|
|
|
private final BillerCategoryWiseRepository billerRepo;
|
|
private final CustomerParamGroupByBillerIdRepository customerParamGroupByBillerIdRepo;
|
|
private final AmountOptionByBillerIdRepository amountOptionByBillerIdRepository;
|
|
private final PlanResponseRepository planResponseRepository;
|
|
private final CategoryResponseListRepository categoryResponseListRepository;
|
|
private final FetchBillValidateRepository fetchBillValidateRepository;
|
|
private final ComplaintStatusRepository complaintStatusRepository;
|
|
private final ReOpenComplaintRepository reOpenComplaintRepository;
|
|
private final ComplaintHistoryRepository complaintHistoryRepository;
|
|
|
|
public BillerMapperHelper(BillerCategoryWiseRepository billerRepo,
|
|
CustomerParamGroupByBillerIdRepository customerParamGroupByBillerIdRepo,
|
|
AmountOptionByBillerIdRepository amountOptionByBillerIdRepository,
|
|
PlanResponseRepository planResponseRepository,
|
|
CategoryResponseListRepository categoryResponseListRepository,
|
|
FetchBillValidateRepository fetchBillValidateRepository,
|
|
ComplaintStatusRepository complaintStatusRepository, ReOpenComplaintRepository reOpenComplaintRepository,
|
|
ComplaintHistoryRepository complaintHistoryRepository) {
|
|
this.billerRepo = billerRepo;
|
|
this.customerParamGroupByBillerIdRepo = customerParamGroupByBillerIdRepo;
|
|
this.amountOptionByBillerIdRepository = amountOptionByBillerIdRepository;
|
|
this.planResponseRepository = planResponseRepository;
|
|
this.categoryResponseListRepository = categoryResponseListRepository;
|
|
this.fetchBillValidateRepository = fetchBillValidateRepository;
|
|
this.complaintStatusRepository = complaintStatusRepository;
|
|
this.reOpenComplaintRepository = reOpenComplaintRepository;
|
|
this.complaintHistoryRepository = complaintHistoryRepository;
|
|
}
|
|
|
|
/**
|
|
* Maps a list of MasterCategoryBillerResponse DTOs to entities, saves them, and
|
|
* returns the saved list
|
|
*/
|
|
public List<BillerCategoryWise> mapAndSaveAll(List<MasterCategoryBillerResponse> dtos, String requestId,
|
|
String txnId) {
|
|
if (dtos == null || dtos.isEmpty()) {
|
|
return Collections.emptyList();
|
|
}
|
|
|
|
List<BillerCategoryWise> entities = new ArrayList<>();
|
|
|
|
for (MasterCategoryBillerResponse dto : dtos) {
|
|
// Check if biller already exists
|
|
BillerCategoryWise biller = billerRepo.findById(dto.getBillerId()).orElse(new BillerCategoryWise()); // create
|
|
// Set/update fields
|
|
biller.setBillerId(dto.getBillerId());
|
|
biller.setBillerName(dto.getBillerName());
|
|
biller.setBillerType(dto.getBillerType());
|
|
biller.setBillerCategory(dto.getBillerCategory());
|
|
biller.setBillerCoverage(dto.getBillerCoverage());
|
|
biller.setBillerResponseType(dto.getBillerResponseType());
|
|
biller.setBillerDescription(dto.getBillerDescription());
|
|
biller.setPlanMDMRequirement(dto.getPlanMDMRequirement());
|
|
biller.setAdhocBiller(dto.getAdhocBiller());
|
|
biller.setPaymentAmountExactness(dto.getPaymentAmountExactness());
|
|
biller.setCreateDateTime(new Date());
|
|
biller.setRequestId(requestId);
|
|
biller.setTxnId(txnId);
|
|
|
|
// Handle icon
|
|
BillerIconDTO iconDTO = dto.getBiller_icon();
|
|
if (iconDTO != null) {
|
|
BillerCategoryIcon icon;
|
|
if (biller.getIcon() != null) {
|
|
icon = biller.getIcon(); // update existing icon
|
|
} else {
|
|
icon = new BillerCategoryIcon();
|
|
icon.setBiller(biller);
|
|
}
|
|
icon.setIconData(iconDTO.getIcon_data());
|
|
icon.setIconType(iconDTO.getIcon_type());
|
|
biller.setIcon(icon); // set to biller
|
|
}
|
|
|
|
entities.add(biller);
|
|
}
|
|
|
|
// Save all at once
|
|
return billerRepo.saveAll(entities);
|
|
}
|
|
|
|
public CustomerParamGroupsDTO saveCustomerParamGroups(CustomerParamGroupsDTO dtos, String requestId, String txnId) {
|
|
if (dtos == null || dtos.getGroups() == null || dtos.getGroups().isEmpty()) {
|
|
return new CustomerParamGroupsDTO(); // Return empty DTO if no groups exist
|
|
}
|
|
|
|
List<CustomerParamGroupById> entities = new ArrayList<>();
|
|
|
|
// Loop through the top-level groups and save them (including nested groups)
|
|
for (GroupDTO groupDTO : dtos.getGroups()) {
|
|
CustomerParamGroupById entity = saveGroupWithChildren(groupDTO, null, requestId, txnId); // null is for root
|
|
// (no
|
|
// parent group)
|
|
entities.add(entity); // Add the saved entity to the list
|
|
|
|
}
|
|
|
|
// Save all entities at once using the repository
|
|
List<CustomerParamGroupById> savedEntities = customerParamGroupByBillerIdRepo.saveAll(entities);
|
|
|
|
// Convert saved entities back into DTOs to return
|
|
return convertEntitiesToDTO(savedEntities);
|
|
}
|
|
|
|
private CustomerParamGroupById saveGroupWithChildren(GroupDTO groupDTO, CustomerParamGroupById parentGroup,
|
|
String requestId, String txnId) {
|
|
|
|
// Create a new entity for the group
|
|
CustomerParamGroupById groupEntity = new CustomerParamGroupById();
|
|
groupEntity.setGroupId(groupDTO.getGroupId());
|
|
groupEntity.setName(groupDTO.getName());
|
|
groupEntity.setInput(groupDTO.getInput());
|
|
groupEntity.setParentGroup(parentGroup); // Link to the parent group (if exists)
|
|
groupEntity.setRequestId(requestId);
|
|
groupEntity.setTxnId(txnId);
|
|
groupEntity.setCreateDateTime(new Date());
|
|
// Save group parameters (if any)
|
|
if (groupDTO.getParams() != null && !groupDTO.getParams().isEmpty()) {
|
|
List<GroupParam> groupParams = new ArrayList<>();
|
|
for (String paramName : groupDTO.getParams()) {
|
|
GroupParam param = new GroupParam();
|
|
param.setParamName(paramName); // Set the parameter name (e.g., "Admission No")
|
|
param.setGroup(groupEntity); // Link the parameter to the current group
|
|
groupParams.add(param);
|
|
}
|
|
groupEntity.setParams(groupParams); // Link parameters to the group
|
|
}
|
|
|
|
// Recursively save child groups if they exist
|
|
if (groupDTO.getGroups() != null && !groupDTO.getGroups().isEmpty()) {
|
|
List<CustomerParamGroupById> childEntities = new ArrayList<>();
|
|
for (GroupDTO childGroupDTO : groupDTO.getGroups()) {
|
|
CustomerParamGroupById childEntity = saveGroupWithChildren(childGroupDTO, groupEntity, requestId,
|
|
txnId); // Pass
|
|
// current
|
|
// group
|
|
// as
|
|
// parent
|
|
childEntities.add(childEntity);
|
|
}
|
|
groupEntity.setChildGroups(childEntities); // Set the child groups
|
|
}
|
|
|
|
// Save the current group entity and return it
|
|
return groupEntity;
|
|
}
|
|
|
|
private CustomerParamGroupsDTO convertEntitiesToDTO(List<CustomerParamGroupById> savedEntities) {
|
|
|
|
if (savedEntities == null || savedEntities.isEmpty()) {
|
|
// Return an empty or default DTO if no entities are found
|
|
return new CustomerParamGroupsDTO(); // return an empty DTO object
|
|
}
|
|
|
|
CustomerParamGroupsDTO responseDTO = new CustomerParamGroupsDTO();
|
|
List<GroupDTO> savedGroups = new ArrayList<>();
|
|
|
|
// Convert each saved entity to DTO
|
|
for (CustomerParamGroupById savedEntity : savedEntities) {
|
|
GroupDTO groupDTO = new GroupDTO();
|
|
groupDTO.setGroupId(savedEntity.getGroupId());
|
|
groupDTO.setName(savedEntity.getName());
|
|
groupDTO.setInput(savedEntity.getInput());
|
|
|
|
// Recursively map child groups if they exist
|
|
if (savedEntity.getChildGroups() != null) {
|
|
List<GroupDTO> childGroupDTOs = new ArrayList<>();
|
|
for (CustomerParamGroupById childEntity : savedEntity.getChildGroups()) {
|
|
GroupDTO childGroupDTO = new GroupDTO();
|
|
childGroupDTO.setGroupId(childEntity.getGroupId());
|
|
childGroupDTO.setName(childEntity.getName());
|
|
childGroupDTO.setInput(childEntity.getInput());
|
|
// childGroupDTO.setParams(childEntity.getParams()); // Set parameters of child
|
|
// group
|
|
childGroupDTOs.add(childGroupDTO);
|
|
}
|
|
groupDTO.setGroups(childGroupDTOs);
|
|
}
|
|
|
|
// Add the DTO to the response
|
|
savedGroups.add(groupDTO);
|
|
}
|
|
|
|
responseDTO.setGroups(savedGroups);
|
|
return responseDTO;
|
|
}
|
|
|
|
// Method to save AmountOptionsResponse and AmountOption entities
|
|
public String saveAmountOptionsResponse(AmountOptionsResponse responseWrapper, String requestId, String txnId) {
|
|
// Convert AmountOptionsResponseDTO to AmountOptionsResponse entity
|
|
|
|
if (responseWrapper == null) {
|
|
// Return an empty or default DTO if no entities are found
|
|
return "Data Is Empty"; // return an empty DTO object
|
|
}
|
|
AmountOptionByBillerId entity = new AmountOptionByBillerId();
|
|
entity.setAmountOptions(responseWrapper.getAmountOptions());
|
|
|
|
// Map AmountOptionDTO list to AmountOptionDetails entities
|
|
List<AmountOptionDetails> amountOptionDetailsList = mapAmountOptionDTOToEntity(
|
|
responseWrapper.getAmountOptionDAOS(), requestId, txnId);
|
|
|
|
// Set the mapped AmountOptionDetails list to AmountOptionByBillerId entity
|
|
entity.setAmountOptionDetails(amountOptionDetailsList);
|
|
entity.setCreateDateTime(new Date());
|
|
|
|
// Save AmountOptionByBillerId entity (this will also save related
|
|
// AmountOptionDetails entities)
|
|
amountOptionByBillerIdRepository.save(entity); // Saves the entity and cascades to AmountOptionDetails
|
|
|
|
// Return success message
|
|
return "Data saved successfully!";
|
|
}
|
|
|
|
private List<AmountOptionDetails> mapAmountOptionDTOToEntity(List<AmountOptionDTO> amountOptionDTOs,
|
|
String requestId, String txnId) {
|
|
|
|
// If the list is null or empty, return an empty list of entities
|
|
if (amountOptionDTOs == null || amountOptionDTOs.isEmpty()) {
|
|
return new ArrayList<>(); // Return an empty list of AmountOptionDetails
|
|
}
|
|
|
|
// AmountOptionDetails entities
|
|
return amountOptionDTOs.stream().flatMap(dto ->
|
|
// For each DTO, convert its breakup sets to AmountOptionDetails entities
|
|
dto.getAmountBreakupSets().stream().map(breakup -> {
|
|
// Create a new AmountOptionDetails entity for each breakup set
|
|
AmountOptionDetails amountOptionDetails = new AmountOptionDetails();
|
|
|
|
// Set the breakup set as a separate entity (each breakup set becomes a new
|
|
// record)
|
|
amountOptionDetails.setAmountBreakupSet(breakup); // Store each breakup set as an individual record
|
|
|
|
// You can optionally set the amountOptionId here, if you want to link this
|
|
// detail to the parent.
|
|
// Assuming you want to set it directly here or pass it via the entity later:
|
|
amountOptionDetails.setAmountOptionId(dto.getAmountOptionId());
|
|
amountOptionDetails.setRequestId(requestId);
|
|
amountOptionDetails.setTxnId(txnId);
|
|
|
|
// Return the mapped AmountOptionDetails entity
|
|
return amountOptionDetails;
|
|
})).collect(Collectors.toList()); // Collect them into a list and return
|
|
}
|
|
|
|
public PlanResponses savePlanResponse(PlanResponse planResponse, String reqId, String txnId) {
|
|
PlanResponses response = new PlanResponses();
|
|
response.setRequestId(reqId);
|
|
response.setPageNo(planResponse.getPageNo());
|
|
response.setPageSize(planResponse.getPageSize());
|
|
response.setTotalElements(planResponse.getTotalElements());
|
|
response.setTotalPages(planResponse.getTotalPages());
|
|
response.setTxnId(txnId);
|
|
response.setCreateDateTime(new Date());
|
|
|
|
PlansList plansList = new PlansList();
|
|
List<Plan> planEntities = new ArrayList<>();
|
|
|
|
for (PlanDTO dto : planResponse.getPlansList().getPlans()) {
|
|
Plan plan = new Plan();
|
|
plan.setPlanId(dto.getPlanId());
|
|
plan.setDescription(dto.getDescription());
|
|
plan.setBillerId(dto.getBillerId());
|
|
plan.setCategoryType(dto.getCategoryType());
|
|
plan.setAmountInRupees(dto.getAmountInRupees());
|
|
plan.setEffctvFrom(dto.getEffctvFrom());
|
|
plan.setEffctvTo(dto.getEffctvTo());
|
|
plan.setStatus(dto.getStatus());
|
|
plan.setPlansList(plansList);
|
|
|
|
// categorySubType
|
|
List<PlanCategorySubType> subs = new ArrayList<>();
|
|
if (dto.getCategorySubType() != null) {
|
|
for (String s : dto.getCategorySubType()) {
|
|
PlanCategorySubType sub = new PlanCategorySubType();
|
|
sub.setCategorySubType(s);
|
|
sub.setPlan(plan);
|
|
subs.add(sub);
|
|
}
|
|
}
|
|
plan.setCategorySubTypes(subs);
|
|
|
|
// additionalInfo + tags
|
|
// ✅ additionalInfo + tags
|
|
if (dto.getAdditionalInfo() != null) {
|
|
AdditionalInfoPlans info = new AdditionalInfoPlans();
|
|
info.setPlanAdditionalInfoId(dto.getAdditionalInfo().getPlanAdditionalInfoId().toString());
|
|
|
|
List<com.billpaymentservice.bbps.entites.PlanTag> tagEntities = new ArrayList<>();
|
|
if (dto.getAdditionalInfo().getTags() != null && !dto.getAdditionalInfo().getTags().isEmpty()) {
|
|
for (com.billpaymentservice.bbps.dto.PlanTag tagDto : dto.getAdditionalInfo().getTags()) {
|
|
com.billpaymentservice.bbps.entites.PlanTag tagEntity = new com.billpaymentservice.bbps.entites.PlanTag();
|
|
tagEntity.setTagId(tagDto.getTagId().toString());
|
|
tagEntity.setName(tagDto.getName());
|
|
tagEntity.setValue(tagDto.getValue());
|
|
tagEntity.setAdditionalInfo(info); // ✅ maintain relationship
|
|
tagEntities.add(tagEntity);
|
|
}
|
|
}
|
|
|
|
// ✅ Now set the entity list
|
|
info.setTags(tagEntities);
|
|
plan.setAdditionalInfo(info);
|
|
}
|
|
|
|
planEntities.add(plan);
|
|
}
|
|
|
|
plansList.setPlans(planEntities);
|
|
response.setPlansList(plansList);
|
|
|
|
return planResponseRepository.save(response);
|
|
}
|
|
|
|
public String saveCategoryItems(List<String> categoryRespList, String requestId, String txnId) {
|
|
int savedCount = 0; // To track how many items were saved
|
|
|
|
if (categoryRespList == null || categoryRespList.isEmpty()) {
|
|
return "No items to save.";
|
|
}
|
|
|
|
for (String item : categoryRespList) {
|
|
CategoryResponseList category = new CategoryResponseList();
|
|
category.setCategoryRespList(item);
|
|
category.setRequestId(txnId);
|
|
category.setRequestId(requestId);
|
|
category.setCreateDateTime(new Date());
|
|
categoryResponseListRepository.save(category);
|
|
savedCount++;
|
|
}
|
|
return savedCount + " items were successfully saved.";
|
|
}
|
|
|
|
public String saveComplaintStatus(ComplaintStatusResponse response, String reqId, String txnId) {
|
|
|
|
if (response == null || response.getComplaints() == null) {
|
|
throw new IllegalArgumentException("Invalid complaint response received!");
|
|
}
|
|
|
|
ComplainDetailsDto dto = response.getComplaints();
|
|
|
|
// ✅ Create and populate entity
|
|
ComplainStatus entity = new ComplainStatus();
|
|
entity.setComplaintId(dto.getComplaintId());
|
|
entity.setComplaintDescr(dto.getComplaintDescr());
|
|
entity.setComplaintDispos(dto.getComplaintDispos());
|
|
entity.setComplaintType(dto.getComplaintType());
|
|
entity.setTxnId(dto.getTxnId());
|
|
entity.setComplaintStatus(dto.getComplaintStatus());
|
|
entity.setAssignedTo(dto.getAssignedTo());
|
|
entity.setComplaintNpciId(dto.getComplaintNpciId());
|
|
entity.setComplaintRaisedFrom(dto.getComplaintRaisedFrom());
|
|
entity.setUserId(dto.getUserId());
|
|
entity.setStatus(dto.getStatus());
|
|
entity.setRefId(dto.getRefId());
|
|
entity.setEstimatedTAT(dto.getEstimated_TAT()); // ✅ added missing field
|
|
entity.setCreationDate(dto.getCreationDate());
|
|
entity.setModifiedDate(dto.getModifiedDate());
|
|
entity.setBillerName(dto.getBillerName());
|
|
entity.setTxnAmount(dto.getTxnAmount());
|
|
entity.setSuperLevelEsc(dto.getSuperLevelEsc());
|
|
entity.setOpenComplaint(dto.getOpenComplaint());
|
|
entity.setReopenComplaint(dto.getReopenComplaint());
|
|
entity.setRemarks(dto.getRemarks());
|
|
entity.setAgentId(dto.getAgentId());
|
|
entity.setCategory(dto.getCategory());
|
|
entity.setCreatedEpochDate(dto.getCreatedEpochDate());
|
|
entity.setModifiedEpochDate(dto.getModifiedEpochDate());
|
|
entity.setRefId(reqId);
|
|
entity.setSystemTxnId(txnId);
|
|
|
|
try {
|
|
ComplainStatus savedEntity = complaintStatusRepository.save(entity);
|
|
if (savedEntity != null && savedEntity.getId() != null) {
|
|
return "Complaint saved successfully with ID: " + savedEntity.getId();
|
|
} else {
|
|
return " Complaint not saved — unexpected error!";
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return " Error saving complaint: " + e.getMessage();
|
|
}
|
|
}
|
|
|
|
public String saveReOpenComplaint(ComplaintStatusResponse response, String reqId, String txnId) {
|
|
|
|
if (response == null || response.getComplaints() == null) {
|
|
throw new IllegalArgumentException("Invalid complaint response received!");
|
|
}
|
|
|
|
ComplainDetailsDto dto = response.getComplaints();
|
|
|
|
// ✅ Create and populate entity
|
|
ReOpenComplain entity = new ReOpenComplain();
|
|
entity.setComplaintId(dto.getComplaintId());
|
|
entity.setComplaintDescr(dto.getComplaintDescr());
|
|
entity.setComplaintDispos(dto.getComplaintDispos());
|
|
entity.setComplaintType(dto.getComplaintType());
|
|
entity.setTxnId(dto.getTxnId());
|
|
entity.setComplaintStatus(dto.getComplaintStatus());
|
|
entity.setAssignedTo(dto.getAssignedTo());
|
|
entity.setComplaintNpciId(dto.getComplaintNpciId());
|
|
entity.setComplaintRaisedFrom(dto.getComplaintRaisedFrom());
|
|
entity.setUserId(dto.getUserId());
|
|
entity.setStatus(dto.getStatus());
|
|
entity.setRefId(dto.getRefId());
|
|
entity.setEstimatedTAT(dto.getEstimated_TAT()); // ✅ added missing field
|
|
entity.setCreationDate(dto.getCreationDate());
|
|
entity.setModifiedDate(dto.getModifiedDate());
|
|
entity.setBillerName(dto.getBillerName());
|
|
entity.setTxnAmount(dto.getTxnAmount());
|
|
entity.setSuperLevelEsc(dto.getSuperLevelEsc());
|
|
entity.setOpenComplaint(dto.getOpenComplaint());
|
|
entity.setReopenComplaint(dto.getReopenComplaint());
|
|
entity.setRemarks(dto.getRemarks());
|
|
entity.setAgentId(dto.getAgentId());
|
|
entity.setCategory(dto.getCategory());
|
|
entity.setCreatedEpochDate(dto.getCreatedEpochDate());
|
|
entity.setModifiedEpochDate(dto.getModifiedEpochDate());
|
|
entity.setRefId(reqId);
|
|
entity.setSystemTxnId(txnId);
|
|
|
|
try {
|
|
ReOpenComplain savedEntity = reOpenComplaintRepository.save(entity);
|
|
if (savedEntity != null && savedEntity.getId() != null) {
|
|
return "ReOpen Complaint saved successfully with ID: " + savedEntity.getId();
|
|
} else {
|
|
return " ReOpen Complaint not saved — unexpected error!";
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return " Error saving complaint: " + e.getMessage();
|
|
}
|
|
}
|
|
|
|
public String saveComplaintHistory(ComplaintHistoryStatusResponse responseWrapper, String reqId, String txnId) {
|
|
if (responseWrapper == null || responseWrapper.getComplaintsHistories() == null
|
|
|| responseWrapper.getComplaintsHistories().isEmpty()) {
|
|
return "No complaint history data found to save.";
|
|
}
|
|
|
|
try {
|
|
int savedCount = 0;
|
|
|
|
for (ComplaintHistoryDTO dto : responseWrapper.getComplaintsHistories()) {
|
|
|
|
ComplaintHistory entity = new ComplaintHistory();
|
|
entity.setComplaintHistoryId(dto.getComplaintHistoryId());
|
|
entity.setComplaintId(dto.getComplaintId());
|
|
entity.setComplaintDescr(dto.getComplaintDescr());
|
|
entity.setComplaintDispos(dto.getComplaintDispos());
|
|
entity.setTxnId(dto.getTxnId());
|
|
entity.setAssignedTo(dto.getAssignedTo());
|
|
entity.setComplaintNpciId(dto.getComplaintNpciId());
|
|
entity.setComplaintType(dto.getComplaintType());
|
|
entity.setComplaintRaisedFrom(dto.getComplaintRaisedFrom());
|
|
entity.setUserId(dto.getUserId());
|
|
entity.setStatus(dto.getStatus());
|
|
entity.setModifiedDate(dto.getModifiedDate());
|
|
entity.setModifiedEpochDate(dto.getModifiedEpochDate());
|
|
entity.setReqId(reqId);
|
|
entity.setSystemTxnId(txnId);
|
|
entity.setCreateDateTime(new Date());
|
|
entity.setPageNo(responseWrapper.getPageNo());
|
|
entity.setPageSize(responseWrapper.getPageSize());
|
|
entity.setTotalElements(responseWrapper.getTotalElements());
|
|
entity.setTotalPages(responseWrapper.getTotalPages());
|
|
|
|
complaintHistoryRepository.save(entity);
|
|
savedCount++;
|
|
}
|
|
|
|
return "✅ " + savedCount + " Complaint history record(s) saved successfully.";
|
|
|
|
} catch (Exception e) {
|
|
// Log the error for debugging
|
|
LOGGER.error("❌ Error saving complaint history data: {}", e.getMessage(), e);
|
|
return "❌ Failed to save complaint history data due to: " + e.getMessage();
|
|
}
|
|
}
|
|
|
|
}
|