Merge pull request 'feature3' (#11) from feature3 into develop

Reviewed-on: https://git.zeptic.in/himanshu/bbps/pulls/11

src/main/java/com/billpaymentservice/bbps/controller/ComplainController.java

@@ -1,5 +1,9 @@
 package com.billpaymentservice.bbps.controller;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
@@ -9,34 +13,62 @@ 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.RestController;
+
 import com.billpaymentservice.bbps.dto.ResponseModel;
-import com.billpaymentservice.bbps.dto.request.BillPaymentRequest;
+import com.billpaymentservice.bbps.dto.request.CloseComplaintRequest;
+import com.billpaymentservice.bbps.dto.request.ComplainStatusRequest;
 import com.billpaymentservice.bbps.dto.request.ComplaintRequestDTO;
+import com.billpaymentservice.bbps.dto.request.ReOpenComplain;
 import com.billpaymentservice.bbps.service.ComplainService;
-import com.billpaymentservice.bbps.service.PaymentService;
 
 @RestController
-@RequestMapping("/complain")
+@RequestMapping("/complaints")
+@Validated
 @CrossOrigin(origins = "*")
 public class ComplainController {
 
+	private static final Logger log = LoggerFactory.getLogger(ComplainController.class);
 
 	private final ComplainService complainService;
+
+	// ✅ Constructor name fixed and variable consistent
 	public ComplainController(ComplainService complainService) {
-		this.complainService=complainService;
+		this.complainService = complainService;
 	}
 
-    @PostMapping(
+	@PostMapping(value = "/addComplain", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
-        value = "/addComplain",
+	public ResponseEntity<ResponseModel> addComplain(@Validated @RequestBody ComplaintRequestDTO complainRequestDTO) {
-        consumes = MediaType.APPLICATION_JSON_VALUE,
-        produces = MediaType.APPLICATION_JSON_VALUE
-    )
-    public ResponseEntity<ResponseModel> addComplain(
-            @Validated @RequestBody ComplaintRequestDTO complainRequestDTO) {
 
-        ResponseModel response = complainService.addComplain(complainRequestDTO);
+		ResponseModel response = complainService.addComplain(complainRequestDTO);
-        return ResponseEntity.ok(response);
+		return ResponseEntity.ok(response);
-    }
+	}
 
+	@PostMapping("/checkComplaintStatus")
+	public ResponseEntity<ResponseModel> getComplaintStatus(@RequestBody ComplainStatusRequest request) {
+		log.info("Received complaint status request for complaintId: {}", request.getComplaintId());
+		ResponseModel response = complainService.getComplaintStatus(request);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping("/reOpenComplaint")
+	public ResponseEntity<ResponseModel> reOpenComplaint(@RequestBody ReOpenComplain request) {
+		log.info("Received ReOpen Complaint request for complaintId: {}", request.getComplaintId());
+		ResponseModel response = complainService.reOpenComplaint(request);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping("/viewComplainsHistory")
+	public ResponseEntity<ResponseModel> viewComplaintHistory(@RequestBody ComplainStatusRequest request) {
+		log.info("Received complaint View Complaint History request for complaintId: {}", request.getComplaintId());
+		ResponseModel response = complainService.viewComplaintHistory(request);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping("/closeComplaint")
+	public ResponseEntity<ResponseModel> closeComplaint(@RequestBody CloseComplaintRequest request) {
+		log.info("Received complaint Close Complaint request for complaintId: {}", request.getComplaintId());
+		ResponseModel response = complainService.closeComplaint(request);
+		return ResponseEntity.ok(response);
+	}
 
 }

src/main/java/com/billpaymentservice/bbps/dto/CloseComplaintDTO.java

@@ -0,0 +1,36 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class CloseComplaintDTO {
+
+	private String complaintId;
+	private String complaintDescr;
+	private String complaintDispos;
+	private String complaintType;
+	private String txnId;
+	private String complaintStatus;
+	private String assignedTo;
+	private String complaintNpciId;
+	private String complaintRaisedFrom;
+	private String userId;
+	private String status;
+	private String refId;
+	private String estimatedTAT;
+	private String creationDate; // ISO 8601 format
+	private String modifiedDate; // ISO 8601 format
+	private String billerName;
+	private String txnAmount;
+	private String superLevelEsc; // True/False
+	private String openComplaint; // Y/N
+	private String reopenComplaint; // Y/N
+	private String remarks;
+	private String agentId;
+	private String category;
+	private Long createdEpochDate; // UNIX timestamp
+	private Long modifiedEpochDate; // UNIX timestamp
+
+}

src/main/java/com/billpaymentservice/bbps/dto/ComplainDetailsDto.java

@@ -0,0 +1,36 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class ComplainDetailsDto {
+
+	private String complaintId;
+	private String complaintDescr;
+	private String complaintDispos;
+	private String complaintType;
+	private String txnId;
+	private String complaintStatus;
+	private String assignedTo;
+	private String complaintNpciId;
+	private String complaintRaisedFrom;
+	private String userId;
+	private String status;
+	private String refId;
+	private String estimated_TAT;
+	private String creationDate;
+	private String modifiedDate;
+	private String billerName;
+	private String txnAmount;
+	private String superLevelEsc;
+	private String openComplaint;
+	private String reopenComplaint;
+	private String remarks;
+	private String agentId;
+	private String category;
+	private long createdEpochDate;
+	private long modifiedEpochDate;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/ComplaintHistoryDTO.java

@@ -0,0 +1,25 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class ComplaintHistoryDTO {
+
+	private String complaintHistoryId;
+	private String complaintId;
+	private String complaintDescr;
+	private String complaintDispos;
+	private String txnId;
+	private String assignedTo;
+	private String complaintNpciId;
+	private String complaintType;
+	private String complaintRaisedFrom;
+	private String userId;
+	private String status;
+	private String modifiedDate; // ISO 8601 Timestamp
+	private Long modifiedEpochDate; // UNIX Epoch
+	private String tenantId;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/request/CloseComplaintRequest.java

@@ -0,0 +1,17 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class CloseComplaintRequest extends BaseClass {
+
+	@NotBlank(message = "complaintDescr not be null")
+	private String complaintDescr;
+
+	@NotBlank(message = "complaintId not be null")
+	private String complaintId;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/request/ComplainStatusRequest.java

@@ -0,0 +1,18 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class ComplainStatusRequest extends BaseClass {
+
+	@NotBlank(message = "Complaint Id cannot be null or blank")
+	private String complaintId;
+}

src/main/java/com/billpaymentservice/bbps/dto/request/ReOpenComplain.java

@@ -0,0 +1,14 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class ReOpenComplain extends BaseClass {
+
+	private String complaintDescr;
+
+	private String complaintId;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/response/CloseComplaintStatusResponse.java

@@ -0,0 +1,16 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.billpaymentservice.bbps.entites.CloseComplaint;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class CloseComplaintStatusResponse {
+
+	private CloseComplaint complaint; // main complaint details
+	private GeneralResp generalResp;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/response/ComplaintHistoryStatusResponse.java

@@ -0,0 +1,28 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.ComplaintHistoryDTO;
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ComplaintHistoryStatusResponse {
+
+	private List<ComplaintHistoryDTO> complaintsHistories;
+	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+	private GeneralResp generalResp;
+	private int pageNo;
+	private int pageSize;
+	private int totalPages;
+	private int totalElements;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/response/ComplaintStatusResponse.java

@@ -0,0 +1,16 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import com.billpaymentservice.bbps.dto.ComplainDetailsDto;
+import com.billpaymentservice.bbps.dto.GeneralResp;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class ComplaintStatusResponse {
+
+	private ComplainDetailsDto complaints;
+	private GeneralResp generalResp;
+
+}

src/main/java/com/billpaymentservice/bbps/entites/AdditionalInfoPlans.java

@@ -16,18 +16,18 @@ import lombok.Getter;
 import lombok.Setter;
 
 @Entity
-@Table(name = "additional_info")
+@Table(name = "plan_additional_info")
 @Getter
 @Setter
 public class AdditionalInfoPlans {
 
 	@Id
-	@GeneratedValue(strategy = GenerationType.AUTO)
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
 	private Long id;
 
 	@Column(name = "plan_ddditional_info_id")
-	private Long planAdditionalInfoId;
+	private String planAdditionalInfoId;
 
-	@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+	@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "additionalInfo")
 	private List<PlanTag> tags;
 }

src/main/java/com/billpaymentservice/bbps/entites/CloseComplaint.java

@@ -0,0 +1,107 @@
+package com.billpaymentservice.bbps.entites;
+
+import com.billpaymentservice.bbps.audit.Auditable;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "complaints")
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class CloseComplaint extends Auditable<String> {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	@Column(name = "id")
+	private Long id;
+
+	@Column(name = "complaint_id")
+	private String complaintId; // UUID
+
+	@Column(name = "complaint_descr")
+	private String complaintDescr;
+
+	@Column(name = "complaint_dispos")
+	private String complaintDispos;
+
+	@Column(name = "complaint_type")
+	private String complaintType;
+
+	@Column(name = "txn_id")
+	private String txnId;
+
+	@Column(name = "complaint_status")
+	private String complaintStatus;
+
+	@Column(name = "assigned_to")
+	private String assignedTo;
+
+	@Column(name = "complaint_npci_id")
+	private String complaintNpciId;
+
+	@Column(name = "complaint_raised_from")
+	private String complaintRaisedFrom;
+
+	@Column(name = "user_id")
+	private String userId;
+
+	@Column(name = "status")
+	private String status;
+
+	@Column(name = "ref_id")
+	private String refId;
+
+	@Column(name = "estimated_tat")
+	private String estimatedTAT;
+
+	@Column(name = "creation_date")
+	private String creationDate; // ISO 8601 format
+
+	@Column(name = "modified_date")
+	private String modifiedDate; // ISO 8601 format
+
+	@Column(name = "biller_name")
+	private String billerName;
+
+	@Column(name = "txn_amount")
+	private String txnAmount;
+
+	@Column(name = "super_level_esc")
+	private String superLevelEsc; // True/False
+
+	@Column(name = "open_complaint")
+	private String openComplaint; // Y/N
+
+	@Column(name = "reopen_complaint")
+	private String reopenComplaint; // Y/N
+
+	@Column(name = "remarks", columnDefinition = "TEXT")
+	private String remarks;
+
+	@Column(name = "agent_id")
+	private String agentId;
+
+	@Column(name = "category")
+	private String category;
+
+	@Column(name = "created_epoch_date")
+	private Long createdEpochDate;
+
+	@Column(name = "modified_epoch_date")
+	private Long modifiedEpochDate;
+
+	@Column(name = "req_id")
+	private String reqId;
+
+	@Column(name = "system_txn_id")
+	private String systemTxnId;
+}

src/main/java/com/billpaymentservice/bbps/entites/ComplainStatus.java

@@ -0,0 +1,106 @@
+package com.billpaymentservice.bbps.entites;
+
+import com.billpaymentservice.bbps.audit.Auditable;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "complaint_status")
+@Getter
+@Setter
+public class ComplainStatus extends Auditable<String> {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	@Column(name = "id")
+	private Long id;
+
+	@Column(name = "complaint_id")
+	private String complaintId;
+
+	@Column(name = "complaint_descr")
+	private String complaintDescr;
+
+	@Column(name = "complaint_dispos")
+	private String complaintDispos;
+
+	@Column(name = "complaint_type")
+	private String complaintType;
+
+	@Column(name = "txn_id")
+	private String txnId;
+
+	@Column(name = "complaint_status")
+	private String complaintStatus;
+
+	@Column(name = "assigned_to")
+	private String assignedTo;
+
+	@Column(name = "complaint_npci_id")
+	private String complaintNpciId;
+
+	@Column(name = "complaint_raised_from")
+	private String complaintRaisedFrom;
+
+	@Column(name = "user_id")
+	private String userId;
+
+	@Column(name = "status")
+	private String status;
+
+	@Column(name = "ref_id")
+	private String refId;
+
+	@Column(name = "estimated_tat")
+	private String estimatedTAT;
+
+	@Column(name = "creation_date")
+	private String creationDate;
+
+	@Column(name = "modified_date")
+	private String modifiedDate;
+
+	@Column(name = "biller_name")
+	private String billerName;
+
+	@Column(name = "txn_amount")
+	private String txnAmount;
+
+	@Column(name = "super_level_esc")
+	private String superLevelEsc;
+
+	@Column(name = "open_complaint")
+	private String openComplaint;
+
+	@Column(name = "reopen_complaint")
+	private String reopenComplaint;
+
+	@Column(name = "remarks")
+	private String remarks;
+
+	@Column(name = "agent_id")
+	private String agentId;
+
+	@Column(name = "category")
+	private String category;
+
+	@Column(name = "created_epoch_date")
+	private long createdEpochDate;
+
+	@Column(name = "modified_epoch_date")
+	private long modifiedEpochDate;
+
+	@Column(name = "req_id")
+	private String reqId;
+
+	@Column(name = "system_txn_id")
+	private String systemTxnId;
+
+}

src/main/java/com/billpaymentservice/bbps/entites/ComplaintHistory.java

@@ -0,0 +1,89 @@
+package com.billpaymentservice.bbps.entites;
+
+import com.billpaymentservice.bbps.audit.Auditable;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Table(name = "complaints_history")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ComplaintHistory extends Auditable<String> {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id; 
+
+	@Column(name = "complaint_id")
+	private String complaintId;
+
+	@Column(name = "complaint_descr")
+	private String complaintDescr;
+
+	@Column(name = "complaint_dispos")
+	private String complaintDispos;
+
+	@Column(name = "txn_id")
+	private String txnId;
+
+	@Column(name = "complaint_history_id")
+	private String complaintHistoryId;
+
+	@Column(name = "assigned_to")
+	private String assignedTo;
+
+	@Column(name = "complaint_npci_id")
+	private String complaintNpciId;
+
+	@Column(name = "complaint_raised_from")
+	private String complaintRaisedFrom;
+
+	@Column(name = "user_id")
+	private String userId;
+
+	@Column(name = "status")
+	private String status;
+
+	@Column(name = "ref_id")
+	private String refId;
+
+	@Column(name = "complaint_type")
+	private String complaintType; // internalComplaint or npciComplaint
+
+	@Column(name = "modified_date")
+	private String modifiedDate; // ISO 8601 timestamp
+
+	@Column(name = "modified_epoch_date")
+	private Long modifiedEpochDate; // UNIX epoch timestamp
+
+	@Column(name = "page_no")
+	private int pageNo;
+
+	@Column(name = "page_size")
+	private int pageSize;
+
+	@Column(name = "total_pages")
+	private int totalPages;
+
+	@Column(name = "total_elements")
+	private int totalElements;
+
+	@Column(name = "system_txn_id")
+	private String systemTxnId;
+
+	@Column(name = "req_id")
+	private String reqId;
+	
+
+}

src/main/java/com/billpaymentservice/bbps/entites/Plan.java

@@ -30,7 +30,7 @@ public class Plan {
 	@Column(name = "plan_id")
 	private String planId;
 
-	@Column(name = "description")
+	@Column(name = "description", columnDefinition = "TEXT")
 	private String description;
 
 	@Column(name = "biller_id")
@@ -51,15 +51,15 @@ public class Plan {
 	@Column(name = "status")
 	private String status;
 
-	@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "plan")
-	private List<PlanCategorySubType> categorySubTypes; // List of categorySubTypes
-
 	@ManyToOne(fetch = FetchType.LAZY)
 	@JoinColumn(name = "plans_list_id")
 	private PlansList plansList;
 
+	@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "plan")
+	private List<PlanCategorySubType> categorySubTypes; // List of categorySubTypes
+
 	@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
-	@JoinColumn(name = "additional_info_id")
+	@JoinColumn(name = "additional_info_id", referencedColumnName = "id")
 	private AdditionalInfoPlans additionalInfo;
 
 }

src/main/java/com/billpaymentservice/bbps/entites/PlanResponses.java

@@ -10,7 +10,7 @@ import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToOne;
 import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
@@ -25,7 +25,7 @@ public class PlanResponses extends Auditable<String> {
 	@GeneratedValue(strategy = GenerationType.IDENTITY)
 	private Long id;
 
-	@ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+	@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
 	@JoinColumn(name = "plans_list_id")
 	private PlansList plansList;
 

src/main/java/com/billpaymentservice/bbps/entites/PlanTag.java

@@ -1,16 +1,6 @@
 package com.billpaymentservice.bbps.entites;
 
-import java.util.UUID;
+import jakarta.persistence.*;
-
-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.JoinColumn;
-import jakarta.persistence.ManyToOne;
-import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -20,18 +10,24 @@ import lombok.Setter;
 @Setter
 public class PlanTag {
 
-	@Id
+    @Id
-	@GeneratedValue(strategy = GenerationType.AUTO)
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
-	private UUID tagId;
+    private Long id;
 
-	@Column(name="name")
+    // UUID is stored as text — perfect, no length limit
-	private String name;
+    @Column(name = "tag_uuid", columnDefinition = "TEXT")
+    private String tagId;
 
-	@Column(name="value")
+    // Use TEXT because tag names like “Additional Benefits” may exceed 255 chars in future
-	private String value;
+    @Column(name = "name", columnDefinition = "TEXT")
+    private String name;
 
-	@ManyToOne(fetch = FetchType.LAZY)
+    // Use TEXT for large values like “Premium Customer Support and 14 OTT Apps”
-	@JoinColumn(name = "plan_id")
+    @Column(name = "value", columnDefinition = "TEXT")
-	private Plan plan;
+    private String value;
 
+    // Foreign key to additional_info table
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "additional_info_id", referencedColumnName = "id")
+    private AdditionalInfoPlans additionalInfo;
 }

src/main/java/com/billpaymentservice/bbps/entites/ReOpenComplain.java

@@ -0,0 +1,106 @@
+package com.billpaymentservice.bbps.entites;
+
+import com.billpaymentservice.bbps.audit.Auditable;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "reopen_complaint")
+@Getter
+@Setter
+public class ReOpenComplain extends Auditable<String> {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	@Column(name = "id")
+	private Long id;
+
+	@Column(name = "complaint_id")
+	private String complaintId;
+
+	@Column(name = "complaint_descr")
+	private String complaintDescr;
+
+	@Column(name = "complaint_dispos")
+	private String complaintDispos;
+
+	@Column(name = "complaint_type")
+	private String complaintType;
+
+	@Column(name = "txn_id")
+	private String txnId;
+
+	@Column(name = "complaint_status")
+	private String complaintStatus;
+
+	@Column(name = "assigned_to")
+	private String assignedTo;
+
+	@Column(name = "complaint_npci_id")
+	private String complaintNpciId;
+
+	@Column(name = "complaint_raised_from")
+	private String complaintRaisedFrom;
+
+	@Column(name = "user_id")
+	private String userId;
+
+	@Column(name = "status")
+	private String status;
+
+	@Column(name = "ref_id")
+	private String refId;
+
+	@Column(name = "estimated_tat")
+	private String estimatedTAT;
+
+	@Column(name = "creation_date")
+	private String creationDate;
+
+	@Column(name = "modified_date")
+	private String modifiedDate;
+
+	@Column(name = "biller_name")
+	private String billerName;
+
+	@Column(name = "txn_amount")
+	private String txnAmount;
+
+	@Column(name = "super_level_esc")
+	private String superLevelEsc;
+
+	@Column(name = "open_complaint")
+	private String openComplaint;
+
+	@Column(name = "reopen_complaint")
+	private String reopenComplaint;
+
+	@Column(name = "remarks")
+	private String remarks;
+
+	@Column(name = "agent_id")
+	private String agentId;
+
+	@Column(name = "category")
+	private String category;
+
+	@Column(name = "created_epoch_date")
+	private long createdEpochDate;
+
+	@Column(name = "modified_epoch_date")
+	private long modifiedEpochDate;
+
+	@Column(name = "req_id")
+	private String reqId;
+
+	@Column(name = "system_txn_id")
+	private String systemTxnId;
+
+}

src/main/java/com/billpaymentservice/bbps/repository/ComplaintHistoryRepository.java

@@ -0,0 +1,11 @@
+package com.billpaymentservice.bbps.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import com.billpaymentservice.bbps.entites.ComplaintHistory;
+
+@Repository
+public interface ComplaintHistoryRepository extends JpaRepository<ComplaintHistory, Long> {
+
+}

src/main/java/com/billpaymentservice/bbps/repository/ComplaintStatusRepository.java

@@ -0,0 +1,11 @@
+package com.billpaymentservice.bbps.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import com.billpaymentservice.bbps.entites.ComplainStatus;
+
+@Repository
+public interface ComplaintStatusRepository extends JpaRepository<ComplainStatus, Long> {
+
+}

src/main/java/com/billpaymentservice/bbps/repository/ReOpenComplaintRepository.java

@@ -0,0 +1,11 @@
+package com.billpaymentservice.bbps.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import com.billpaymentservice.bbps.entites.ReOpenComplain;
+
+@Repository
+public interface ReOpenComplaintRepository extends JpaRepository<ReOpenComplain, Long> {
+
+}

src/main/java/com/billpaymentservice/bbps/service/ComplainService.java

@@ -1,10 +1,21 @@
 package com.billpaymentservice.bbps.service;
 
 import com.billpaymentservice.bbps.dto.ResponseModel;
+import com.billpaymentservice.bbps.dto.request.CloseComplaintRequest;
+import com.billpaymentservice.bbps.dto.request.ComplainStatusRequest;
+import com.billpaymentservice.bbps.dto.request.ReOpenComplain;
 import com.billpaymentservice.bbps.dto.request.ComplaintRequestDTO;
 
 public interface ComplainService {
 
+	ResponseModel getComplaintStatus(ComplainStatusRequest request);
+
+	ResponseModel reOpenComplaint(ReOpenComplain request);
+
+	ResponseModel viewComplaintHistory(ComplainStatusRequest request);
+
+	ResponseModel closeComplaint(CloseComplaintRequest request);
+
 	public ResponseModel addComplain(ComplaintRequestDTO complainRequestDTO);
 
 }

src/main/java/com/billpaymentservice/bbps/serviceImpl/ComplainServiceImpl.java

@@ -10,6 +10,17 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestClient;
+
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.billpaymentservice.bbps.dto.ResponseModel;
+import com.billpaymentservice.bbps.dto.request.CloseComplaintRequest;
+import com.billpaymentservice.bbps.dto.request.ComplainStatusRequest;
+import com.billpaymentservice.bbps.dto.request.ReOpenComplain;
+import com.billpaymentservice.bbps.dto.response.CloseComplaintStatusResponse;
+import com.billpaymentservice.bbps.dto.response.ComplaintHistoryStatusResponse;
+import com.billpaymentservice.bbps.dto.response.ComplaintStatusResponse;
+import com.billpaymentservice.bbps.entites.BharatConnectMaster;
 
 import com.billpaymentservice.bbps.dto.GeneralResp;
 import com.billpaymentservice.bbps.dto.ResponseModel;
@@ -24,6 +35,11 @@ import com.billpaymentservice.bbps.entites.InboundTraceLog;
 import com.billpaymentservice.bbps.entites.OutboundTraceLog;
 import com.billpaymentservice.bbps.exception.CustomException;
 import com.billpaymentservice.bbps.repository.BharatConnectMasterRepository;
+import com.billpaymentservice.bbps.service.ComplainService;
+import com.billpaymentservice.bbps.util.BBPSConstant;
+import com.billpaymentservice.bbps.util.BillerMapperHelper;
+import com.billpaymentservice.bbps.util.Helper;
+import com.fasterxml.jackson.annotation.JsonInclude;
 import com.billpaymentservice.bbps.repository.ComplainRepository;
 import com.billpaymentservice.bbps.service.ComplainService;
 import com.billpaymentservice.bbps.util.BBPSConstant;
@@ -35,25 +51,33 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 
 @Service
 public class ComplainServiceImpl implements ComplainService {
-	 @Value("${complaint.data.url}")
-	 private String complainDataUrl;
-	 public static final Logger LOGGER = LoggerFactory.getLogger(ComplainServiceImpl.class);
-	 private final Helper helper;
-     private final ObjectMapper objectMapper = new ObjectMapper();
-     private final BharatConnectMasterRepository beneficiaryDetailsRepository;
 
-	 private final HttpService httpService;
+	@Value("${agent.data.url}")
-	 private final ComplainRepository complainRepository;
+	private String agentDtaUrl;
 
-	 public ComplainServiceImpl(Helper helper
+	@Value("${complaint.data.url}")
-			 ,HttpService httpService,
+	private String complainDataUrl;
-			 BharatConnectMasterRepository beneficiaryDetailsRepository,
+
-			 ComplainRepository complainRepository) {
+	private final RestClient restClient;
-		 this.helper=helper;
+	private final HttpService httpService;
-		 this.httpService=httpService;
+	private final Helper helper;
-		 this.beneficiaryDetailsRepository=beneficiaryDetailsRepository;
+	private final BharatConnectMasterRepository beneficiaryDetailsRepository;
-		 this.complainRepository=complainRepository;
+	private final BillerMapperHelper mapperHelper;
-	 }
+	private final ComplainRepository complainRepository;
+
+	private final ObjectMapper objectMapper = new ObjectMapper();
+	private static final Logger LOGGER = LoggerFactory.getLogger(AgentServiceImpl.class);
+
+	public ComplainServiceImpl(RestClient restClient, HttpService httpService, Helper helper,
+			BharatConnectMasterRepository beneficiaryDetailsRepository, BillerMapperHelper mapperHelper,
+			ComplainRepository complainRepository) {
+		this.restClient = restClient;
+		this.httpService = httpService;
+		this.helper = helper;
+		this.beneficiaryDetailsRepository = beneficiaryDetailsRepository;
+		this.mapperHelper = mapperHelper;
+		this.complainRepository = complainRepository;
+	}
 
 	@Override
 	public ResponseModel addComplain(ComplaintRequestDTO complainRequestDTO) {
@@ -65,12 +89,12 @@ public class ComplainServiceImpl implements ComplainService {
 		String requestId = complainRequestDTO.getReqId();
 		String fullUrl = complainDataUrl + BBPSConstant.ADD_COMPLAIN_ENDPOINT;
 		String requestJson = helper.convertObjectToJson(complainRequestDTO);
-		   BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
+		BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
-		    HttpHeaders headers = new HttpHeaders();
+		HttpHeaders headers = new HttpHeaders();
-		    headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
+		headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
-		    headers.set("agentId", headersData.getAgentId());
+		headers.set("agentId", headersData.getAgentId());
-		    headers.set("tenantId", headersData.getTenantId());
+		headers.set("tenantId", headersData.getTenantId());
-		    headers.setContentType(MediaType.APPLICATION_JSON);
+		headers.setContentType(MediaType.APPLICATION_JSON);
 
 		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnId, apiName, complainRequestDTO.getMid(),
 				"POST", requestJson);
@@ -96,12 +120,12 @@ public class ComplainServiceImpl implements ComplainService {
 
 			ComplaintResponse responseWrapper = objectMapper.convertValue(dataMap, ComplaintResponse.class);
 			GeneralResp generalResp = responseWrapper.getGeneralResp();
-			 ModelMapper mapper = new ModelMapper();
+			ModelMapper mapper = new ModelMapper();
-		        mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
+			mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
-		        ComplaintDetails entity = mapper.map(responseWrapper.getComplaints(), ComplaintDetails.class);
+			ComplaintDetails entity = mapper.map(responseWrapper.getComplaints(), ComplaintDetails.class);
-		        entity.setReqId(complainRequestDTO.getReqId());
+			entity.setReqId(complainRequestDTO.getReqId());
-		        entity.setTxnId(txnId);
+			entity.setTxnId(txnId);
-		       complainRepository.save(entity);
+			complainRepository.save(entity);
 			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
 					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
 			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
@@ -111,8 +135,272 @@ public class ComplainServiceImpl implements ComplainService {
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		}
+	}
 
+	@Override
+	public ResponseModel getComplaintStatus(ComplainStatusRequest request) {
+		LOGGER.info("Fetching Compalint Status by Complaint Id={}", request.getComplaintId(), request.getReqId());
+		String apiName = "Complaint Status";
+		String txnId = helper.generateTxnId(15);
+		String reqId = request.getReqId();
+		String complaintId = request.getComplaintId();
+		String fullUrl = agentDtaUrl + BBPSConstant.COMPALINT_STATUS;
 
+		helper.validateMerchant(request.getMid());
+
+		BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
+		HttpHeaders headers = new HttpHeaders();
+		headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
+		headers.set("agentId", headersData.getAgentId());
+		headers.set("tenantId", headersData.getTenantId());
+		headers.setContentType(MediaType.APPLICATION_JSON);
+
+		ObjectMapper objectMapper = new ObjectMapper();
+		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		String requestJson = helper.convertObjectToJson(request);
+
+		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "POST",
+				requestJson);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "POST", complaintId);
+		LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
+
+		try {
+			LOGGER.info("Calling external API: {}", fullUrl);
+			Map<String, String> responseMap = httpService.postRequest(fullUrl, requestJson, headers);
+			String responseData = responseMap.get("data");
+			LOGGER.info("Complaint FetchById Response: {}", responseData);
+
+			helper.updateOutboundLogResponse(outboundLog, responseData);
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("genericResponse")) {
+				helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+				LOGGER.warn("Invalid response structure for txnId: {}", txnId);
+				throw new CustomException(String.valueOf(dataMap.get("message")), String.valueOf(dataMap.get("status")),
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
+						String.valueOf(dataMap.get("remarks")));
+			}
+
+			ComplaintStatusResponse responseWrapper = objectMapper.convertValue(dataMap, ComplaintStatusResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			String status = generalResp.getStatus();
+			LOGGER.info("Current Complaint Status: {}", status);
+
+			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+			mapperHelper.saveComplaintStatus(responseWrapper, reqId, txnId);
+			LOGGER.info("Complaint data saved successfully for billId: {}", complaintId);
+
+			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+		} catch (JsonProcessingException e) {
+			LOGGER.error("Error parsing Complaint Id JSON: {}", e.getMessage(), e);
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
+		}
+	}
+
+	@Override
+	public ResponseModel reOpenComplaint(ReOpenComplain request) {
+		LOGGER.info("Fetching ReOpen Complaint by Complaint Id={}", request.getComplaintId(), request.getReqId());
+		String apiName = "Complaint Status";
+		String txnId = helper.generateTxnId(15);
+		String reqId = request.getReqId();
+		String complaintId = request.getComplaintId();
+		String fullUrl = agentDtaUrl + BBPSConstant.REOPEN_COMPALINT;
+
+		helper.validateMerchant(request.getMid());
+
+		BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
+		HttpHeaders headers = new HttpHeaders();
+		headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
+		headers.set("agentId", headersData.getAgentId());
+		headers.set("tenantId", headersData.getTenantId());
+		headers.setContentType(MediaType.APPLICATION_JSON);
+
+		ObjectMapper objectMapper = new ObjectMapper();
+		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		String requestJson = helper.convertObjectToJson(request);
+
+		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "POST",
+				requestJson);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "POST", complaintId);
+		LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
+
+		try {
+			LOGGER.info("Calling external API: {}", fullUrl);
+			Map<String, String> responseMap = httpService.postRequest(fullUrl, requestJson, headers);
+			String responseData = responseMap.get("data");
+			LOGGER.info("Complaint ReOpen FetchById Response: {}", responseData);
+
+			helper.updateOutboundLogResponse(outboundLog, responseData);
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("genericResponse")) {
+				helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+				LOGGER.warn("Invalid response structure for txnId: {}", txnId);
+				throw new CustomException(String.valueOf(dataMap.get("message")), String.valueOf(dataMap.get("status")),
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
+						String.valueOf(dataMap.get("remarks")));
+			}
+
+			ComplaintStatusResponse responseWrapper = objectMapper.convertValue(dataMap, ComplaintStatusResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			String status = generalResp.getStatus();
+			LOGGER.info("Current Complaint ReOpen Status: {}", status);
+
+			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+			mapperHelper.saveReOpenComplaint(responseWrapper, reqId, txnId);
+			LOGGER.info("Complaint ReOpen data saved successfully for billId: {}", complaintId);
+
+			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+		} catch (JsonProcessingException e) {
+			LOGGER.error("Error parsing Complaint Id JSON: {}", e.getMessage(), e);
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
+		}
+	}
+
+	@Override
+	public ResponseModel viewComplaintHistory(ComplainStatusRequest request) {
+		LOGGER.info("Fetching View Complaint History Complaint by Complaint Id={}", request.getComplaintId(),
+				request.getReqId());
+		String apiName = "Complaint Status";
+		String txnId = helper.generateTxnId(15);
+		String reqId = request.getReqId();
+		String complaintId = request.getComplaintId();
+		String fullUrl = agentDtaUrl + BBPSConstant.COMPLAINT_HISTORY + request.getComplaintId();
+
+		helper.validateMerchant(request.getMid());
+
+		BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
+		HttpHeaders headers = new HttpHeaders();
+		headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
+		headers.set("agentId", headersData.getAgentId());
+		headers.set("tenantId", headersData.getTenantId());
+		headers.setContentType(MediaType.APPLICATION_JSON);
+
+		ObjectMapper objectMapper = new ObjectMapper();
+		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		String requestJson = helper.convertObjectToJson(request);
+
+		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "GET",
+				requestJson);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", complaintId);
+		LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
+
+		try {
+			LOGGER.info("Calling external API: {}", fullUrl);
+			Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
+			String responseData = responseMap.get("data");
+			LOGGER.info("Complaint History Complaint FetchById Response: {}", responseData);
+
+			helper.updateOutboundLogResponse(outboundLog, responseData);
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("generalResp")) {
+				helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+				LOGGER.warn("Invalid response structure for txnId: {}", txnId);
+				throw new CustomException(String.valueOf(dataMap.get("message")), String.valueOf(dataMap.get("status")),
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), String.valueOf(""));
+			}
+
+			ComplaintHistoryStatusResponse responseWrapper = objectMapper.convertValue(dataMap,
+					ComplaintHistoryStatusResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			String status = generalResp.getStatus();
+			LOGGER.info("Current Complaint ReOpen Status: {}", status);
+
+			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+			String saveComplaintHistory = mapperHelper.saveComplaintHistory(responseWrapper, reqId, txnId);
+			LOGGER.info("Complaint ReOpen data saved successfully for Count History: {}", saveComplaintHistory);
+
+			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+		} catch (JsonProcessingException e) {
+			LOGGER.error("Error parsing Complaint Id JSON: {}", e.getMessage(), e);
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
+		}
+	}
+
+	@Override
+	public ResponseModel closeComplaint(CloseComplaintRequest request) {
+		LOGGER.info("Fetching Close Complaint by Complaint Id={}", request.getComplaintId(), request.getReqId());
+		String apiName = "Complaint Status";
+		String txnId = helper.generateTxnId(15);
+		String reqId = request.getReqId();
+		String complaintId = request.getComplaintId();
+		String fullUrl = agentDtaUrl + BBPSConstant.CLOSE_COMPLAINT;
+
+		helper.validateMerchant(request.getMid());
+
+		BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
+		HttpHeaders headers = new HttpHeaders();
+		headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
+		headers.set("agentId", headersData.getAgentId());
+		headers.set("tenantId", headersData.getTenantId());
+		headers.setContentType(MediaType.APPLICATION_JSON);
+
+		ObjectMapper objectMapper = new ObjectMapper();
+		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		String requestJson = helper.convertObjectToJson(request);
+
+		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "POST",
+				requestJson);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "POST", complaintId);
+		LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
+
+		try {
+			LOGGER.info("Calling external API: {}", fullUrl);
+			Map<String, String> responseMap = httpService.postRequest(fullUrl, requestJson, headers);
+			String responseData = responseMap.get("data");
+			LOGGER.info("Complaint Close FetchById Response: {}", responseData);
+
+			helper.updateOutboundLogResponse(outboundLog, responseData);
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("genericResponse")) {
+				helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+				LOGGER.warn("Invalid response structure for txnId: {}", txnId);
+				throw new CustomException(String.valueOf(dataMap.get("message")), String.valueOf(dataMap.get("status")),
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
+						String.valueOf(dataMap.get("remarks")));
+			}
+
+			CloseComplaintStatusResponse responseWrapper = objectMapper.convertValue(dataMap,
+					CloseComplaintStatusResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			String status = generalResp.getStatus();
+			LOGGER.info("Current Complaint Close Status: {}", status);
+
+			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+			// mapperHelper.saveReOpenComplaint(responseWrapper, reqId, txnId);
+			LOGGER.info("Complaint Close data saved successfully for billId: {}", complaintId);
+
+			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+		} catch (JsonProcessingException e) {
+			LOGGER.error("Error parsing Complaint Id JSON: {}", e.getMessage(), e);
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
+		}
 	}
 
 }

src/main/java/com/billpaymentservice/bbps/serviceImpl/HttpService.java

@@ -114,8 +114,8 @@ public class HttpService {
             HttpHeaders headers = new HttpHeaders();
             headers.setContentType(MediaType.APPLICATION_JSON);
 
-            log.info("🌐 Sending GET request to: {}", url);
+//            log.info("🌐 Sending GET request to: {}", url);
-            log.info("📦 Headers: {}", headers);
+//            log.info("📦 Headers: {}", headers);
 
             ResponseEntity<String> restResponse = restClient.get()
                     .uri(url)
@@ -127,7 +127,7 @@ public class HttpService {
             response.put("respCode", String.valueOf(restResponse.getStatusCode().value()));
             response.put("data", restResponse.getBody());
 
-            log.info("✅ GET Response: {}", restResponse.getBody());
+          //  log.info("✅ GET Response: {}", restResponse.getBody());
 
         } catch (HttpClientErrorException | HttpServerErrorException httpException) {
             log.error("❌ HTTP Error: {}", httpException.getMessage(), httpException);

src/main/java/com/billpaymentservice/bbps/serviceImpl/MasterDataServiceImpl.java

@@ -123,7 +123,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 			Map<String, String> responseMap = httpService.getRequest(fullUrl);
 			String responseData = responseMap.get("data");
 
-			LOGGER.info("Response Data: {}", responseData);
+			//LOGGER.info("Response Data: {}", responseData);
 			helper.updateOutboundLogResponse(outboundLog, responseData);
 			Map<String, Object> dataMap = objectMapper.readValue(responseData,
 					new TypeReference<Map<String, Object>>() {
@@ -292,7 +292,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 			Map<String, String> responseMap = httpService.getRequest(fullUrl);
 			String responseData = responseMap.get("data");
-			LOGGER.info("Response Data: {}", responseData);
+			//LOGGER.info("Response Data: {}", responseData);
 
 			helper.updateOutboundLogResponse(outboundLog, responseData);
 

src/main/java/com/billpaymentservice/bbps/util/BBPSConstant.java

@@ -42,6 +42,10 @@ public class BBPSConstant {
 	public static final String PAYMENT_URL = "/agent/bills/payment";
 	public static final String CHECK_TRANSACTION_URL = "/transactions/payment/byTxnId?txnId=";
 	public static final String DISPOSTION_URL = "/disposition";
+	public static final String COMPALINT_STATUS = "/couapp/complaints/status";
+	public static final String REOPEN_COMPALINT = "/couapp/complaints/reopen";
+	public static final String COMPLAINT_HISTORY = "/couapp/complaints/history/byId?complaintId=";
+	public static final String CLOSE_COMPLAINT = " /couapp/complaints/closure";
 
 	public static final String PLANS_URL = "/plans";
 	public static final String ADD_COMPLAIN_ENDPOINT = "/couapp/complaints";

src/main/java/com/billpaymentservice/bbps/util/BillerMapperHelper.java

@@ -6,55 +6,80 @@ import java.util.Date;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import org.modelmapper.ModelMapper;
+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.FetchBillValidateResponse;
+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.FetchBillValidate;
 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) {
+			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;
 	}
 
 	/**
@@ -273,22 +298,73 @@ public class BillerMapperHelper {
 		})).collect(Collectors.toList()); // Collect them into a list and return
 	}
 
-	public PlanResponses savePlanResponse(PlanResponse planResponseDTO, String requestId, String txnId) {
+	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());
 
-		// If the list is null or empty, return an empty list of entities
+		PlansList plansList = new PlansList();
-		if (planResponseDTO == null) {
+		List<Plan> planEntities = new ArrayList<>();
-			return new PlanResponses(); // Return an empty list of AmountOptionDetails
+
+		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);
 		}
 
-		// Convert DTO to Entity using ModelMapper
+		plansList.setPlans(planEntities);
-		ModelMapper modelMapper = new ModelMapper();
+		response.setPlansList(plansList);
-		PlanResponses planResponseEntity = modelMapper.map(planResponseDTO, PlanResponses.class);
+
-		// Save the entity to the database
+		return planResponseRepository.save(response);
-		// Set the requestId and txnId in the entity
-		planResponseEntity.setRequestId(requestId);
-		planResponseEntity.setTxnId(txnId);
-		planResponseEntity.setCreateDateTime(new Date());
-		return planResponseRepository.save(planResponseEntity);
 	}
 
 	public String saveCategoryItems(List<String> categoryRespList, String requestId, String txnId) {
@@ -310,30 +386,152 @@ public class BillerMapperHelper {
 		return savedCount + " items were successfully saved.";
 	}
 
-	/*
+	public String saveComplaintStatus(ComplaintStatusResponse response, String reqId, String txnId) {
-	 * public FetchBillValidate
+
-	 * saveFetchBillValidateResponse(FetchBillValidateResponse dto, String
+		if (response == null || response.getComplaints() == null) {
-	 * requestId, String txnId) {
+			throw new IllegalArgumentException("Invalid complaint response received!");
-	 * 
+		}
-	 * if (dto == null) { return new FetchBillValidate(); }
+
-	 * 
+		ComplainDetailsDto dto = response.getComplaints();
-	 * // Convert DTO to Entity FetchBillValidate entity = new FetchBillValidate();
+
-	 * 
+		// ✅ Create and populate entity
-	 * entity.setBillId(dto.getBillId()); entity.setRefId(dto.getRefId());
+		ComplainStatus entity = new ComplainStatus();
-	 * entity.setBillerId(dto.getBillerId()); entity.setStatus(dto.getStatus());
+		entity.setComplaintId(dto.getComplaintId());
-	 * entity.setActionType(dto.getActionType()); entity.setUserId(dto.getUserId());
+		entity.setComplaintDescr(dto.getComplaintDescr());
-	 * entity.setBillerResponse(dto.getBillerResponse());
+		entity.setComplaintDispos(dto.getComplaintDispos());
-	 * entity.setAdditionalInfo(dto.getAdditionalInfo());
+		entity.setComplaintType(dto.getComplaintType());
-	 * entity.setCustomerParams(dto.getCustomerParams());
+		entity.setTxnId(dto.getTxnId());
-	 * entity.setPlanInfoDaos(dto.getPlanInfoDaos());
+		entity.setComplaintStatus(dto.getComplaintStatus());
-	 * entity.setCreationDate(dto.getCreationDate());
+		entity.setAssignedTo(dto.getAssignedTo());
-	 * entity.setModifiedDate(dto.getModifiedDate());
+		entity.setComplaintNpciId(dto.getComplaintNpciId());
-	 * entity.setCreatedEpochDate(dto.getCreatedEpochDate());
+		entity.setComplaintRaisedFrom(dto.getComplaintRaisedFrom());
-	 * entity.setModifiedEpochDate(dto.getModifiedEpochDate());
+		entity.setUserId(dto.getUserId());
-	 * entity.setRequestId(requestId); entity.setTxnId(txnId);
+		entity.setStatus(dto.getStatus());
-	 * entity.setCreateDateTime(new Date());
+		entity.setRefId(dto.getRefId());
-	 * 
+		entity.setEstimatedTAT(dto.getEstimated_TAT()); // ✅ added missing field
-	 * // Save the entity in the database return
+		entity.setCreationDate(dto.getCreationDate());
-	 * fetchBillValidateRepository.save(entity); }
+		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();
+		}
+	}
+
 }

src/main/resources/application-local.properties

@@ -12,7 +12,7 @@ spring.jpa.properties.hibernate.default_schema=public
 #swagger.server.url=https://procurelinc.in/BBPS
 #swagger.server.description=Production Server
 
-swagger.server.url=http://192.168.1.2:9090
+swagger.server.url=http://localhost:9090
 
 swagger.server.description=Local Development Server
 
@@ -20,9 +20,9 @@ swagger.server.description=Local Development Server
 # DataSource
 spring.datasource.url=jdbc:postgresql://localhost:5432/BBPS
 spring.datasource.username=postgres
-#spring.datasource.password=
+spring.datasource.password=UAT@DB_2025
 
-spring.datasource.password=himanshu@123
+#spring.datasource.password=himanshu@123
 spring.datasource.driver-class-name=org.postgresql.Driver
 spring.datasource.type=com.zaxxer.hikari.HikariDataSource
 

src/main/resources/application.properties

@@ -12,7 +12,7 @@ spring.jpa.properties.hibernate.default_schema=public
 #swagger.server.url=https://procurelinc.in/BBPS
 #swagger.server.description=Production Server
 
-swagger.server.url=http://192.168.1.24:9090
+swagger.server.url=http://localhost:9090
 
 swagger.server.description=Local Development Server