merged with develop code

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

@@ -58,7 +58,7 @@ public class AgentServiceImpl implements AgentService {
 	private final BillMasterRepository billMasterRepository;
 	private final BillInitateRepository billIntiateRepository;
 	private static final Logger LOGGER = LoggerFactory.getLogger(AgentServiceImpl.class);
-	
+
 	public AgentServiceImpl(RestClient restClient, HttpService httpService, Helper helper,
 			BharatConnectMasterRepository beneficiaryDetailsRepository,
 			InboundTraceLogRepository inboundTraceLogRepository, OutboundTraceLogRepository outboundTraceLogRepository,
@@ -93,12 +93,11 @@ public class AgentServiceImpl implements AgentService {
 
 		ObjectMapper objectMapper = new ObjectMapper();
 		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-		FetchBillForwardRequest forwardReq =
-		      helper.fetchBillForwardRequestMap(fetchBillRequest);
+		FetchBillForwardRequest forwardReq = helper.fetchBillForwardRequestMap(fetchBillRequest);
 
 		String forwardJson = helper.convertObjectToJson(forwardReq);
-		String requestJson=helper.convertObjectToJson(fetchBillRequest);
-		
+		String requestJson = helper.convertObjectToJson(fetchBillRequest);
+
 		// ✅ Create inbound & outbound logs
 		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnId, apiName, fetchBillRequest.getMid(),
 				"POST", requestJson);
@@ -108,7 +107,7 @@ public class AgentServiceImpl implements AgentService {
 
 		try {
 			LOGGER.info("Calling external API: {}", fullUrl);
-			Map<String, String> responseMap = httpService.postRequest(fullUrl,forwardJson, headers);
+			Map<String, String> responseMap = httpService.postRequest(fullUrl, forwardJson, headers);
 			String responseData = responseMap.get("data");
 
 			helper.updateOutboundLogResponse(outboundLog, responseData);
@@ -210,7 +209,7 @@ public class AgentServiceImpl implements AgentService {
 			LOGGER.info("Current Bill Status: {}", status);
 
 			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
-			helper.saveOrUpdateBillData(responseWrapper, billFetchByBillIdRequest,txnId);
+			helper.saveOrUpdateBillData(responseWrapper, billFetchByBillIdRequest, txnId);
 			LOGGER.info("Bill data saved successfully for billId: {}", billId);
 
 			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
@@ -270,6 +269,7 @@ public class AgentServiceImpl implements AgentService {
 	                    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode
 	                    String.valueOf(dataMap.get("remarks")));
 	        }
+		
 
 	        BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
 	        GeneralResp generalResp = responseWrapper.getGenericResponse();
@@ -291,14 +291,12 @@ public class AgentServiceImpl implements AgentService {
 	}
 
 	
-	
-
-	
 
 	@Override
 	public ResponseModel initiateBillValidate(FetchBillValidatestRequest fetchBillValidateRequest) {	
 		LOGGER.info("Initiating bill Validate for request ID: {} and MID:{} and billerId:{}", fetchBillValidateRequest.getReqId(),
 				fetchBillValidateRequest.getMid(),fetchBillValidateRequest.getBillerId());
+
 		String apiName = "InitiateBillValidate";
 		String txnId = helper.generateTxnId(15);
 		String reqId = fetchBillValidateRequest.getReqId();
@@ -315,8 +313,8 @@ public class AgentServiceImpl implements AgentService {
 
 		ObjectMapper objectMapper = new ObjectMapper();
 		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-		FetchBillValidatestForwardRequest forwardReq =
-		        helper.fetchBillValidatestForwardRequest(fetchBillValidateRequest);
+		FetchBillValidatestForwardRequest forwardReq = helper
+				.fetchBillValidatestForwardRequest(fetchBillValidateRequest);
 
 		String forwardJson = helper.convertObjectToJson(forwardReq);
 
@@ -325,8 +323,7 @@ public class AgentServiceImpl implements AgentService {
 		// ✅ Create inbound & outbound logs
 		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, fetchBillValidateRequest.getMid(),
 				"POST", requestJson);
-		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "POST",
-				forwardJson);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "POST", forwardJson);
 		LOGGER.debug("Outbound log created successfully for txnId: {} and reqId: {}", txnId, reqId);
 
 		try {
@@ -337,8 +334,6 @@ public class AgentServiceImpl implements AgentService {
 			helper.updateOutboundLogResponse(outboundLog, responseData);
 			LOGGER.debug("Response received from BBPS: {}", responseData);
 
-
-
 			Map<String, Object> dataMap = objectMapper.readValue(responseData,
 					new TypeReference<Map<String, Object>>() {
 					});
@@ -386,78 +381,77 @@ public class AgentServiceImpl implements AgentService {
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		}
-		
+
+	}
+
+	public ResponseModel BillvaidateByBillId(BillFetchByBillIdRequest billRequest, InboundTraceLog inboundLog) {
+		{
+			LOGGER.info("Validating bill by BILLID for request ID={} and MID={}", billRequest.getReqId(),
+					billRequest.getMid());
+			String apiName = "FetchBillById";
+			String txnId = helper.generateTxnId(15);
+			String reqId = billRequest.getReqId();
+			String billId = billRequest.getBillId();
+			String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_ID_URL + billRequest.getBillId();
+			;
+
+			helper.validateMerchant(billRequest.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();
+			OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", null);
+			LOGGER.debug("Outbound log created successfully for FetchBillById: {}", fullUrl);
+
+			try {
+				LOGGER.info("Calling external API: {}", fullUrl);
+				Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
+				String responseData = responseMap.get("data");
+				LOGGER.info("Bill 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")));
+				}
+
+				FetchBillValidateResponse responseWrapper = objectMapper.convertValue(dataMap,
+						FetchBillValidateResponse.class);
+				GeneralResp generalResp = responseWrapper.getGenericResponse();
+
+				String status = generalResp.getStatus();
+				LOGGER.info("Current Bill Status: {}", status);
+
+				helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+				System.out.println("responseWrapper:" + responseWrapper);
+				helper.saveBillValidation(responseWrapper, billRequest);
+				LOGGER.info("Bill data saved successfully for billId: {}", billId);
+
+				return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+						Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+			} catch (JsonProcessingException e) {
+				LOGGER.error("Error parsing BillById JSON: {}", e.getMessage(), e);
+				helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+				throw new CustomException("Invalid JSON received from API");
 			}
 
+		}
+	}
 
-	
-	public ResponseModel BillvaidateByBillId( BillFetchByBillIdRequest billRequest,InboundTraceLog inboundLog) { {
-	    LOGGER.info("Validating bill by BILLID for request ID={} and MID={}", billRequest.getReqId(), billRequest.getMid());
-	    String apiName = "FetchBillById";
-	    String txnId = helper.generateTxnId(15);
-	    String reqId = billRequest.getReqId();
-	    String billId = billRequest.getBillId();
-	    String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_ID_URL+ billRequest.getBillId(); ;
-
-	    helper.validateMerchant(billRequest.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();
-	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", null);
-	    LOGGER.debug("Outbound log created successfully for FetchBillById: {}", fullUrl);
-
-	    try {
-	        LOGGER.info("Calling external API: {}", fullUrl);
-	        Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
-	        String responseData = responseMap.get("data");
-	        LOGGER.info("Bill 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"))
-	            );
-	        }
-
-	        FetchBillValidateResponse responseWrapper = objectMapper.convertValue(dataMap, FetchBillValidateResponse.class);
-	        GeneralResp generalResp = responseWrapper.getGenericResponse();
-
-	        String status = generalResp.getStatus();
-	        LOGGER.info("Current Bill Status: {}", status);
-
-	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
-	        System.out.println("responseWrapper:"+responseWrapper);
-	       helper.saveBillValidation(responseWrapper,billRequest);
-	        LOGGER.info("Bill data saved successfully for billId: {}", billId);
-
-	        return new ResponseModel(
-	                generalResp.getMessage(),
-	                generalResp.getStatus(),
-	                Integer.parseInt(generalResp.getStatusCode()),
-	                responseWrapper
-	        );
-	    } catch (JsonProcessingException e) {
-	        LOGGER.error("Error parsing BillById JSON: {}", e.getMessage(), e);
-	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
-	        throw new CustomException("Invalid JSON received from API");
-	    }
-	
-	}}
-	
 
 	@Override
 	public ResponseModel initiateBillValidateByBillId(BillFetchByBillIdRequest billRequest) {
@@ -529,134 +523,319 @@ public class AgentServiceImpl implements AgentService {
 	@Override
 	public ResponseModel fetchBillValidateByClientReqId(BillValidateByClientIdRequest billValidateByClientIdRequest) {
 
-	    String apiName = "FetchBillValidateByClientIdRequest";
-	    String txnId = helper.generateTxnId(15);
-	    String reqId = billValidateByClientIdRequest.getReqId();
-	    String clientReqId = billValidateByClientIdRequest.getClientReqId();
+		String apiName = "FetchBillValidateByClientIdRequest";
+		String txnId = helper.generateTxnId(15);
+		String reqId = billValidateByClientIdRequest.getReqId();
+		String clientReqId = billValidateByClientIdRequest.getClientReqId();
 
-	    Optional<BillInitiate> billInitiate = billIntiateRepository.findByReqId(clientReqId);
-	    if (billInitiate.isEmpty()) {
-	        throw new CustomException("No Bill Found for given Client Req Id");
-	    }
+		Optional<BillInitiate> billInitiate = billIntiateRepository.findByReqId(clientReqId);
+		if (billInitiate.isEmpty()) {
+			throw new CustomException("No Bill Found for given Client Req Id");
+		}
 
-	    String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_BY_CLIENT_REQ_ID + billInitiate.get().getTxnId();
+		String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_BY_CLIENT_REQ_ID + billInitiate.get().getTxnId();
 
-	    helper.validateMerchant(billValidateByClientIdRequest.getMid());
+		helper.validateMerchant(billValidateByClientIdRequest.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);
+		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 objectMapper = new ObjectMapper();
 
-	    // 🔵 Create Inbound + Outbound Logs
-	    InboundTraceLog inboundLog = helper.createInboundLog(
-	            reqId, txnId, apiName, billValidateByClientIdRequest.getMid(), "GET", null);
+		// 🔵 Create Inbound + Outbound Logs
+		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName,
+				billValidateByClientIdRequest.getMid(), "GET", null);
 
-	    OutboundTraceLog outboundLog = helper.createOutboundLog(
-	            txnId, reqId, apiName, fullUrl, "GET", null);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", null);
 
-	    try {
-	        LOGGER.info("Calling BBPS API FetchBillValidateByClientReqId, URL={}", fullUrl);
-	        Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
-	        String responseData = responseMap.get("data");
+		try {
+			LOGGER.info("Calling BBPS API FetchBillValidateByClientReqId, URL={}", fullUrl);
+			Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
+			String responseData = responseMap.get("data");
 
-	        helper.updateOutboundLogResponse(outboundLog, responseData);
+			helper.updateOutboundLogResponse(outboundLog, responseData);
 
-	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {
-	        });
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
 
-	        if (!dataMap.containsKey("genericResponse")) {
-	            helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
-	            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")));
-	        }
+			if (!dataMap.containsKey("genericResponse")) {
+				helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+				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")));
+			}
 
-	        FetchBillValidateResponse responseWrapper = objectMapper.convertValue(dataMap,
-	                FetchBillValidateResponse.class);
-	        GeneralResp generalResp = responseWrapper.getGenericResponse();
+			FetchBillValidateResponse responseWrapper = objectMapper.convertValue(dataMap,
+					FetchBillValidateResponse.class);
+			GeneralResp generalResp = responseWrapper.getGenericResponse();
 
-	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
 
-	        return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
-	                Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
 
-	    } catch (JsonProcessingException e) {
-	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
-	        throw new CustomException("Invalid JSON received from API");
-	    }
+		} catch (JsonProcessingException e) {
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
+		}
 	}
 
-	
-
 	@Override
 	public ResponseModel fetchBillByClientReqId(BillFetchByClientIdRequest billFetchByClientIdRequest) {
 
-	    String apiName = "FetchBillByClientIdRequest";
-	    String txnId = helper.generateTxnId(15);
-	    String reqId = billFetchByClientIdRequest.getReqId();
-	    String clientReqId = billFetchByClientIdRequest.getClientReqId();
+		String apiName = "FetchBillByClientIdRequest";
+		String txnId = helper.generateTxnId(15);
+		String reqId = billFetchByClientIdRequest.getReqId();
+		String clientReqId = billFetchByClientIdRequest.getClientReqId();
 
-	    Optional<BillInitiate> billInitiate = billIntiateRepository.findByReqId(clientReqId);
-	    if (billInitiate.isEmpty()) {
-	        throw new CustomException("No Bill Found for given Client Req Id");
-	    }
+		Optional<BillInitiate> billInitiate = billIntiateRepository.findByReqId(clientReqId);
+		if (billInitiate.isEmpty()) {
+			throw new CustomException("No Bill Found for given Client Req Id");
+		}
 
-	    String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_BY_CLIENT_REQ_ID + billInitiate.get().getTxnId();
+		String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_BY_CLIENT_REQ_ID + billInitiate.get().getTxnId();
 
-	    helper.validateMerchant(billFetchByClientIdRequest.getMid());
+		helper.validateMerchant(billFetchByClientIdRequest.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);
+		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 objectMapper = new ObjectMapper();
 
-	    // 🔵 Create inbound + outbound logs  
-	    InboundTraceLog inboundLog = helper.createInboundLog(
-	            reqId, txnId, apiName, billFetchByClientIdRequest.getMid(), "GET", null);
+		// 🔵 Create inbound + outbound logs
+		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, billFetchByClientIdRequest.getMid(),
+				"GET", null);
 
-	    OutboundTraceLog outboundLog = helper.createOutboundLog(
-	            txnId, reqId, apiName, fullUrl, "GET", null);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", null);
 
-	    try {
-	        LOGGER.info("Calling BBPS API FetchBillByClientReqId, URL={}", fullUrl);
-	        Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
-	        String responseData = responseMap.get("data");
+		try {
+			LOGGER.info("Calling BBPS API FetchBillByClientReqId, URL={}", fullUrl);
+			Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
+			String responseData = responseMap.get("data");
 
-	        helper.updateOutboundLogResponse(outboundLog, responseData);
+			helper.updateOutboundLogResponse(outboundLog, responseData);
 
-	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {
-	        });
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
 
-	        if (!dataMap.containsKey("genericResponse")) {
-	            helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
-	            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")));
-	        }
+			if (!dataMap.containsKey("genericResponse")) {
+				helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+				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")));
+			}
 
-	        BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
-	        GeneralResp generalResp = responseWrapper.getGenericResponse();
+			BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
+			GeneralResp generalResp = responseWrapper.getGenericResponse();
 
-	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
 
-	        return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
-	                Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
 
-	    } catch (JsonProcessingException e) {
-	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
-	        throw new CustomException("Invalid JSON received from API");
-	    }
+		} catch (JsonProcessingException e) {
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
+		}
 	}
 
+
+	/*
+	 * @Override public ResponseModel
+	 * initiateBillValidate(FetchBillValidatestRequest fetchBillValidateRequest) {
+	 * 
+	 * ResponseModel responseModel = new ResponseModel(); try {
+	 * 
+	 * helper.validateMerchant(fetchBillValidateRequest.getMid());
+	 * 
+	 * BharatConnectMaster headersData =
+	 * beneficiaryDetailsRepository.findByOrgId("ORG001");
+	 * 
+	 * if (headersData == null) { responseModel = new
+	 * ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST,
+	 * headersData); return responseModel; }
+	 * 
+	 * 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
+	 * json = objectMapper.writeValueAsString(fetchBillValidateRequest); String url
+	 * = agentDtaUrl + BBPSConstant.BILLER_VALIDATE_URL;
+	 * 
+	 * Map<String, String> responseMap = httpService.postRequest(url, json,
+	 * headers); String responseData = responseMap.get("data");
+	 * 
+	 * log.info("📦 Bill Fetch API Response: {}", responseData);
+	 * 
+	 * if (responseData == null || responseData.isEmpty()) { throw new
+	 * CustomException("Empty response from BBPS server"); }
+	 * 
+	 * // ✅ Convert JSON string → Map Map<String, Object> dataMap =
+	 * objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>()
+	 * {});
+	 * 
+	 * // ✅ Validate generalResp if (!dataMap.containsKey("genericResponse")) {
+	 * throw new CustomException("Invalid response structure from BBPS"); }
+	 * 
+	 * // ✅ Convert to your custom DTO FetchBillValidatestResponse fetchBillResponse
+	 * = objectMapper.convertValue(dataMap, FetchBillValidatestResponse.class);
+	 * GeneralResp generalResponse = fetchBillResponse.getGenericResponse();
+	 * 
+	 * // ✅ Build final ResponseModel responseModel = new ResponseModel(
+	 * generalResponse.getMessage(), generalResponse.getStatus(),
+	 * Integer.parseInt(generalResponse.getStatusCode()), fetchBillResponse );
+	 * 
+	 * } catch (CustomException ex) { log.warn("Merchant validation failed: {}",
+	 * ex.getMessage()); return ex.getResponseModel(); // Directly return
+	 * ResponseModel from exception } catch (Exception e) {
+	 * log.error("❌ Exception in initiateBillFetch(): {}", e.getMessage(), e);
+	 * responseModel.setStatus("500");
+	 * responseModel.setMessage("Exception occurred");
+	 * responseModel.setData(e.getMessage()); }
+	 * 
+	 * return responseModel; }
+	 * 
+	 * @Override public ResponseModel
+	 * initiateBillValidateByBillId(BillFetchByBillIdRequest billRequest) {
+	 * 
+	 * ResponseModel responseModel = new ResponseModel(); try {
+	 * helper.validateMerchant(billRequest.getMid());
+	 * 
+	 * BharatConnectMaster headersData =
+	 * beneficiaryDetailsRepository.findByOrgId("ORG001");
+	 * 
+	 * if (headersData == null) { responseModel = new
+	 * ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST,
+	 * headersData); return responseModel; }
+	 * 
+	 * 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
+	 * json = objectMapper.writeValueAsString(billRequest); String url = agentDtaUrl
+	 * + BBPSConstant.BILL_ID_URL + billRequest.getBillId();
+	 * 
+	 * log.info("Full URL: {}", url);
+	 * objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+	 * 
+	 * // ✅ Call the API using httpService Map<String, String> responseMap =
+	 * httpService.getRequest(url, headers); String responseData =
+	 * responseMap.get("data");
+	 * 
+	 * log.info("📦 Bill Fetch API Response: {}", responseData);
+	 * 
+	 * if (responseData == null || responseData.isEmpty()) { throw new
+	 * CustomException("Empty response from BBPS server"); }
+	 * 
+	 * // ✅ Convert JSON string → Map Map<String, Object> dataMap =
+	 * objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>()
+	 * {});
+	 * 
+	 * // ✅ Validate generalResp if (!dataMap.containsKey("genericResponse")) {
+	 * throw new CustomException("Invalid response structure from BBPS"); }
+	 * 
+	 * // ✅ Convert to your custom DTO BillDataResponse fetchBillResponse =
+	 * objectMapper.convertValue(dataMap, BillDataResponse.class); GeneralResp
+	 * generalResponse = fetchBillResponse.getGenericResponse();
+	 * 
+	 * // ✅ Build final ResponseModel responseModel = new ResponseModel(
+	 * generalResponse.getRemarks(), generalResponse.getStatus(),
+	 * Integer.parseInt(generalResponse.getStatusCode()), fetchBillResponse );
+	 * 
+	 * } catch (CustomException ex) { log.warn("Merchant validation failed: {}",
+	 * ex.getMessage()); return ex.getResponseModel(); // Directly return
+	 * ResponseModel from exception } catch (Exception e) {
+	 * log.error("❌ Exception in initiateBillFetch(): {}", e.getMessage(), e);
+	 * responseModel.setStatus("500");
+	 * responseModel.setMessage("Exception occurred");
+	 * responseModel.setData(e.getMessage()); }
+	 * 
+	 * return responseModel; }
+	 */
+
+	/*
+	 * POLLING METHOD public ResponseModel fetchBillById(BillFetchByBillIdRequest
+	 * billFetchByBillIdRequest, InboundTraceLog inboundLog) { String apiName =
+	 * "FetchBillById"; String txnId = helper.generateTxnId(15); String reqId =
+	 * billFetchByBillIdRequest.getReqId(); String billId =
+	 * billFetchByBillIdRequest.getBillId(); String url = agentDtaUrl +
+	 * BBPSConstant.BILL_FETCH_BY_ID + "1ced7566-1add-4e01-9ed6-04cd67ac9684";
+	 * 
+	 * helper.validateMerchant(billFetchByBillIdRequest.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(); OutboundTraceLog outboundLog
+	 * = helper.createOutboundLog(txnId, reqId, apiName, url, "GET", null);
+	 * 
+	 * // ✅ Loop setup long startTime = System.currentTimeMillis(); long
+	 * maxWaitTimeMs = 40000; // 40 seconds long intervalMs = 5000; // 5 seconds
+	 * 
+	 * while (true) { try { Map<String, String> responseMap =
+	 * httpService.getRequest(url, headers); String responseData =
+	 * responseMap.get("data"); log.info("📦 Bill 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");
+	 * 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")) ); }
+	 * 
+	 * BillDataResponse responseWrapper = objectMapper.convertValue(dataMap,
+	 * BillDataResponse.class); GeneralResp generalResp =
+	 * responseWrapper.getGenericResponse();
+	 * 
+	 * String status = generalResp.getStatus();
+	 * log.info("📡 Current Bill Status: {}", status); // ✅ Check for "INPROGRESS"
+	 * or pending state if ("INPROGRESS".equalsIgnoreCase(status)) { if
+	 * (System.currentTimeMillis() - startTime > maxWaitTimeMs) {
+	 * helper.updateInboundLogFailure(inboundLog, "Timeout after 40 seconds",
+	 * "FAILED"); throw new CustomException("Timeout", "FAILED", 408,
+	 * "Bill fetch still in progress"); } Thread.sleep(intervalMs); continue; //
+	 * retry again } // ✅ Final successful response
+	 * helper.updateInboundLogSuccess(inboundLog, responseData,
+	 * generalResp.getStatus()); return new ResponseModel( generalResp.getMessage(),
+	 * generalResp.getStatus(), Integer.parseInt(generalResp.getStatusCode()),
+	 * responseWrapper ); } catch (JsonProcessingException e) {
+	 * log.error("Error parsing BillById JSON: {}", e.getMessage());
+	 * helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+	 * throw new CustomException("Invalid JSON received from API"); } catch
+	 * (InterruptedException e) { Thread.currentThread().interrupt();
+	 * helper.updateInboundLogFailure(inboundLog, e.getMessage(), "INTERRUPTED");
+	 * throw new CustomException("Thread interrupted during bill status check"); } }
+	 * }
+	 */
+
+	
 }

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

@@ -3,8 +3,6 @@ package com.billpaymentservice.bbps.serviceImpl;
 import java.util.List;
 import java.util.Map;
 
-import org.modelmapper.ModelMapper;
-import org.modelmapper.convention.MatchingStrategies;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
@@ -16,22 +14,22 @@ import org.springframework.web.client.RestClient;
 import com.billpaymentservice.bbps.dto.GeneralResp;
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.AllMasterOptionsRequest;
-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.dto.request.GetTicketLatestStausRequest;
 import com.billpaymentservice.bbps.dto.request.TxnStatusRequest;
+import com.billpaymentservice.bbps.dto.request.ViewAllComplaintsTicketsRequest;
+
 import com.billpaymentservice.bbps.dto.request.ViewAllComplaintsRequest;
-import com.billpaymentservice.bbps.dto.request.ViewComplainByIdRequest;
 import com.billpaymentservice.bbps.dto.response.ComplaintHistoryStatusResponse;
 import com.billpaymentservice.bbps.dto.response.ComplaintResponse;
-
-import com.billpaymentservice.bbps.dto.response.ComplaintStatusResponse;
+import com.billpaymentservice.bbps.dto.response.TicketCheckStatusResponse;
 import com.billpaymentservice.bbps.dto.response.TxnStatusResponse;
+
+import com.billpaymentservice.bbps.dto.response.ViewAllComplaintsTicketsResponse;
 import com.billpaymentservice.bbps.dto.response.ViewAllComplaintsResponse;
 import com.billpaymentservice.bbps.dto.response.ViewComplainByIdResponse;
 import com.billpaymentservice.bbps.entites.BharatConnectMaster;
-import com.billpaymentservice.bbps.entites.ComplaintDetails;
 import com.billpaymentservice.bbps.entites.ComplaintStatusOptionsMaster;
 import com.billpaymentservice.bbps.entites.InboundTraceLog;
 import com.billpaymentservice.bbps.entites.OutboundTraceLog;
@@ -47,9 +45,10 @@ import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 
 @Service
-public  class ComplainServiceImpl implements ComplainService {
+public class ComplainServiceImpl implements ComplainService {
 
 	@Value("${agent.data.url}")
 	private String agentDtaUrl;
@@ -84,14 +83,20 @@ public  class ComplainServiceImpl implements ComplainService {
 	@Override
 	public ResponseModel addComplain(ComplaintRequestDTO complainRequestDTO) {
 
-		LOGGER.info("Initiating addComplain for request ID: {} and MID", complainRequestDTO.getReqId(),
+		LOGGER.info("Initiating add Complain for request ID: {} and MID {}", complainRequestDTO.getReqId(),
 				complainRequestDTO.getMid());
-		String apiName = "ADDCOMPLAIN";
+
+		String apiName = "ADD_COMPLAIN";
 		String txnId = helper.generateTxnId(15);
 		String requestId = complainRequestDTO.getReqId();
 		String fullUrl = complainDataUrl + BBPSConstant.ADD_COMPLAIN_ENDPOINT;
+
+		// Convert input DTO to JSON
 		String requestJson = helper.convertObjectToJson(complainRequestDTO);
+
+		// Fetch tenant & agent from DB
 		BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
+
 		HttpHeaders headers = new HttpHeaders();
 		headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
 		headers.set("agentId", headersData.getAgentId());
@@ -100,233 +105,155 @@ public  class ComplainServiceImpl implements ComplainService {
 
 		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnId, apiName, complainRequestDTO.getMid(),
 				"POST", requestJson);
-
 		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, requestId, apiName, fullUrl, "POST", null);
-		LOGGER.info("Calling external API: {}", fullUrl);
-		LOGGER.info("Request payload: {}", requestJson);
-		Map<String, String> responseMap = httpService.postRequest(fullUrl, requestJson, headers);
-		String responseData = responseMap.get("data");
-		LOGGER.info("fetched data from api is :{}", responseData);
-		helper.updateOutboundLogResponse(outboundLog, responseData);
+
 		try {
+			// Inject tenantId + agentId into request JSON
+			ObjectNode root = (ObjectNode) objectMapper.readTree(requestJson);
+			root.put("tenantId", headersData.getTenantId());
+			root.put("agentId", headersData.getAgentId());
+
+			String finalJson = root.toString();
+			LOGGER.info("Final Request Sent to API: {}", finalJson);
+
+			// IMPORTANT: Send finalJson, not requestJson
+			Map<String, String> responseMap = httpService.postRequest(fullUrl, finalJson, headers);
+
+			String responseData = responseMap.get("data");
+			LOGGER.info("Fetched response: {}", responseData);
+
+			helper.updateOutboundLogResponse(outboundLog, responseData);
+
+			// Handle HttpService error wrapper
+			if (responseData.startsWith("HttpService Error")) {
+				int start = responseData.indexOf("{");
+				int end = responseData.lastIndexOf("}");
+				if (start != -1 && end != -1) {
+					responseData = responseData.substring(start, end + 1);
+				}
+				LOGGER.info("Extracted pure JSON from error: {}", responseData);
+			}
+
+			// Parse JSON into Map
 			Map<String, Object> dataMap = objectMapper.readValue(responseData,
 					new TypeReference<Map<String, Object>>() {
 					});
-			LOGGER.info("Parsed response data: {}", dataMap);
-			if (!dataMap.containsKey("generalResp")) {
-				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
+
+			int statusCode = Integer.parseInt(String.valueOf(dataMap.get("statusCode")));
+
+			// Throw exception for non-200
+			if (statusCode != 200) {
 				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")));
+						statusCode, String.valueOf(dataMap.get("remarks")));
 			}
 
+			// Convert to response wrapper
 			ComplaintResponse responseWrapper = objectMapper.convertValue(dataMap, ComplaintResponse.class);
-			GeneralResp generalResp = responseWrapper.getGeneralResp();
-			ModelMapper mapper = new ModelMapper();
-			mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
-			ComplaintDetails entity = mapper.map(responseWrapper.getComplaints(), ComplaintDetails.class);
-			entity.setReqId(complainRequestDTO.getReqId());
-			entity.setTxnId(txnId);
-			complainRepository.save(entity);
-			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
-					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
-			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+
+			ResponseModel responseModel = new ResponseModel(responseWrapper.getMessage(), responseWrapper.getStatus(),
+					Integer.parseInt(responseWrapper.getStatusCode()), responseWrapper);
+
+			helper.updateInboundLogSuccess(inboundLog, responseData, responseWrapper.getStatus());
 			return responseModel;
+
 		} catch (JsonProcessingException e) {
-			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("JSON Parsing Error: {}", e.getMessage());
 			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);
+	public ResponseModel getComplaintStatus(GetTicketLatestStausRequest request) {
+
+		LOGGER.info("Fetching Complaint Status for TicketId={} ReqId={}", request.getTicketId(), request.getReqId());
+
+		String apiName = "COMPLAINT_STATUS";
+		String txnId = helper.generateTxnId(15);
+		String reqId = request.getReqId();
+		String complaintId = request.getTicketId();
+		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);
+
+		// Convert request to JSON
+		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);
 
 		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);
-//
-//			
-//		        
-//			// Dummy complaint map start
-//		        JsonNode root = objectMapper.readTree(responseData);
-//		        String message = root.path("message").asText("");
-//		        String statuss = root.path("status").asText("");
-//
-//			// dummy data send when server response is coming error.
-//			// Check for internal server error
-//			if ("Internal server error, please try again later".equalsIgnoreCase(message)) {
-//
-//				Map<String, Object> dummyComplaint = mapperHelper.getComplaintStatusJson();
-//
-//				LOGGER.info("Returning Dummy Response: {}", dummyComplaint);
-//
-//				// Pass map directly to ResponseModel
-//				return new ResponseModel("Successfully requested complaint status", "success", 200, dummyComplaint);
-//			}
-//			// Dummy complaint map End
-//
-//			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");
 
-			Map<String, Object> dummyComplaint = mapperHelper.getComplaintStatusJson();
+			LOGGER.info("Calling external API: {}", fullUrl);
+			Map<String, String> responseMap = httpService.postRequest(fullUrl, requestJson, headers);
 
-			LOGGER.info("Returning Dummy Response: {}", dummyComplaint);
+			String responseData = responseMap.get("data");
 
-			// Pass map directly to ResponseModel
-			return new ResponseModel("Successfully requested complaint status", "success", 200, dummyComplaint);
+			LOGGER.info("Complaint Fetch Response: {}", responseData);
+			helper.updateOutboundLogResponse(outboundLog, responseData);
 
-			// Dummy complaint map End
+			if (responseData.startsWith("HttpService Error")) {
+				int start = responseData.indexOf("{");
+				int end = responseData.lastIndexOf("}");
+				if (start != -1 && end != -1) {
+					responseData = responseData.substring(start, end + 1);
+					LOGGER.info("Extracted Clean JSON: {}", responseData);
+				}
+			}
 
-		} catch (Exception ex) {
-			LOGGER.error("Error parsing response JSON", ex);
-			throw new CustomException("Error " + ex.getMessage());
-		}
-	}
+			// Convert JSON to Map
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
 
-	@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);
+			int statusCode = Integer.parseInt(String.valueOf(dataMap.get("statusCode")));
 
-		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);
+			if (statusCode != 200) {
+				throw new CustomException(String.valueOf(dataMap.get("message")), String.valueOf(dataMap.get("status")),
+						statusCode, String.valueOf(dataMap.get("remarks")));
+			}
 
-			// Dummy complaint map start
-			// Check for internal server error
+			TicketCheckStatusResponse responseWrapper = objectMapper.convertValue(dataMap,
+					TicketCheckStatusResponse.class);
 
-			Map<String, Object> dummyComplaint = mapperHelper.getDummyReopenComplaintJson();
-			LOGGER.info("Returning Dummy Response: {}", dummyComplaint);
+			LOGGER.info("Complaint Current Status: {}", responseWrapper.getStatus());
 
-			return new ResponseModel("Complaint reopening requested", "success", 200, dummyComplaint);
+			helper.updateInboundLogSuccess(inboundLog, responseData, responseWrapper.getStatus());
 
-			// Dummy complaint map End
+			// Save in DB
+			mapperHelper.saveComplaintStatus(responseWrapper, reqId, txnId);
+
+			return new ResponseModel(responseWrapper.getMessage(), responseWrapper.getStatus(),
+					Integer.parseInt(responseWrapper.getStatusCode()), responseWrapper);
+
+		} catch (JsonProcessingException e) {
+
+			LOGGER.error("Error parsing Complaint Status JSON: {}", e.getMessage());
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
 
-//			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(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");
-		} catch (Exception ex) {
-			LOGGER.error("Error parsing response JSON", ex);
-			throw new CustomException("Error " + ex.getMessage());
 		}
 	}
 
 	@Override
 	public ResponseModel viewComplaintHistory(ComplainStatusRequest request) {
-		LOGGER.info("Fetching View Complaint History Complaint by Complaint Id={}", request.getComplaintId(),
+		LOGGER.info("Fetching View Complaint History Complaint by Complaint Id={}", request.getTicketId(),
 				request.getReqId());
-		String apiName = "Complaint Status";
+		String apiName = "View_Complaint_History";
 		String txnId = helper.generateTxnId(15);
 		String reqId = request.getReqId();
-		String complaintId = request.getComplaintId();
-		String fullUrl = agentDtaUrl + BBPSConstant.COMPLAINT_HISTORY + request.getComplaintId();
+		String ticketId = request.getTicketId();
+		String fullUrl = agentDtaUrl + BBPSConstant.COMPLAINT_HISTORY + request.getTicketId();
 
 		helper.validateMerchant(request.getMid());
 
@@ -343,7 +270,7 @@ public  class ComplainServiceImpl implements ComplainService {
 
 		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "GET",
 				requestJson);
-		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", complaintId);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", ticketId);
 		LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
 
 		try {
@@ -386,92 +313,14 @@ public  class ComplainServiceImpl implements ComplainService {
 	}
 
 	@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);
+	public ResponseModel viewComplaintById(ComplainStatusRequest request) {
 
-		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);
-
-			// Dummy complaint map Start
-			Map<String, Object> dummyComplaint = mapperHelper.getDummyClosureComplaintJson();
-			LOGGER.info("Returning Dummy Response: {}", dummyComplaint);
-
-			return new ResponseModel("Complaint closure requested", "success", 200, dummyComplaint);
-
-			// Dummy complaint map End
-
-//			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");
-		} catch (Exception e) {
-			throw new CustomException("Invalid JSON received from API" + e.getMessage());
-		}
-	}
-
-	@Override
-	public ResponseModel viewComplaintById(ViewComplainByIdRequest request) {
-
-		LOGGER.info("Fetching View Complaint History Complaint by Complaint Id={}", request.getComplaintId(),
-				request.getReqId());
-		String apiName = "View Complaint By ID";
+		LOGGER.info("Fetching View Complaint Complaint by Complaint Id={}", request.getTicketId(), request.getReqId());
+		String apiName = "View_Complaint_By_ID";
 		String txnId = helper.generateTxnId(15);
 		String reqId = request.getReqId();
-		String complaintId = request.getComplaintId();
-		String fullUrl = agentDtaUrl + BBPSConstant.VIEW_COMPLAINT_BY_ID + request.getComplaintId();
+		String ticketId = request.getTicketId();
+		String fullUrl = agentDtaUrl + BBPSConstant.VIEW_COMPLAINT_BY_ID + request.getTicketId();
 
 		helper.validateMerchant(request.getMid());
 
@@ -488,7 +337,7 @@ public  class ComplainServiceImpl implements ComplainService {
 
 		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "GET",
 				requestJson);
-		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", complaintId);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", ticketId);
 		LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
 
 		try {
@@ -518,14 +367,8 @@ public  class ComplainServiceImpl implements ComplainService {
 			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);
 			String saveComplaint = mapperHelper.saveComplainStatusDetail(responseWrapper, reqId, txnId);
-			// LOGGER.info("Complaint ReOpen data saved successfully for Count History: {}",
-			// saveComplaintHistory);
+			LOGGER.info("Complaint ReOpen data saved successfully for Count History: {}", saveComplaint);
 
 			return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
 					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
@@ -540,7 +383,6 @@ public  class ComplainServiceImpl implements ComplainService {
 	public ResponseModel getAllActiveStatuses(AllMasterOptionsRequest request) {
 
 		try {
-
 			LOGGER.info("Fetch All Master Options - MID: {}", request.getMid());
 			String apiName = "View All Options Fetch By Id";
 			String txnId = helper.generateTxnId(15);
@@ -582,7 +424,7 @@ public  class ComplainServiceImpl implements ComplainService {
 	}
 
 	public ResponseModel checkTxnStatus(TxnStatusRequest request) {
-		LOGGER.info("Fetching TxnStatusRequest by  Id={} and ReqId ={}", request.getId(), request.getReqId());
+		LOGGER.info("Check Txn Status Request by Id={} and ReqId ={}", request.getId(), request.getReqId());
 		String apiName = "CheckTxnStatus";
 		String txnId = helper.generateTxnId(15);
 		String reqId = request.getReqId();
@@ -633,11 +475,6 @@ public  class ComplainServiceImpl implements ComplainService {
 			LOGGER.info("Current Complaint ReOpen Status: {}", status);
 
 			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
-			// String saveComplaint = mapperHelper.saveComplainStatusDetail(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) {
@@ -649,75 +486,72 @@ public  class ComplainServiceImpl implements ComplainService {
 	}
 
 	@Override
-	public ResponseModel ViewAllComplaints(ViewAllComplaintsRequest request) {
-		   
-				LOGGER.info("Fetching All Complaint for status Type={} and reqId={} ", request.getStatusType(),
-						request.getReqId());
-				String apiName = "View All Complaint By Status Type";
-				String txnId = helper.generateTxnId(15);
-				String reqId = request.getReqId();
-				String fullUrl = complainDataUrl+ BBPSConstant.VIEW_ALL_COMPLAINTS_BASE
-				        + "?pageNo=" + request.getPageNo()
-				        + "&pageSize=" + request.getPageSize()
-				        + "&statusType=" + request.getStatusType();
+	public ResponseModel ViewAllComplaints(ViewAllComplaintsTicketsRequest request) {
 
-				helper.validateMerchant(request.getMid());
+		LOGGER.info("Fetching All Complaint for status Type={} and reqId={} ", request.getStatusType(),
+				request.getReqId());
+		String apiName = "View_All_Complaint_By_Status_Type";
+		String txnId = helper.generateTxnId(15);
+		String reqId = request.getReqId();
+		String fullUrl = complainDataUrl + BBPSConstant.VIEW_ALL_COMPLAINTS_BASE + "?pageNo=" + request.getPageNo()
+				+ "&pageSize=" + request.getPageSize() + "&statusType=" + request.getStatusType() + "&ticketType="
+				+ request.getTicketType();
 
-				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);
+		helper.validateMerchant(request.getMid());
 
-				ObjectMapper objectMapper = new ObjectMapper();
-				objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-				String requestJson = helper.convertObjectToJson(request);
+		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);
 
-				InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "POST",
-						requestJson);
-				OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", request.getStatusType());
-				LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
+		ObjectMapper objectMapper = new ObjectMapper();
+		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		String requestJson = helper.convertObjectToJson(request);
 
-				try {
-					LOGGER.info("Calling external API: {}", fullUrl);
-					Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
-					String responseData = responseMap.get("data");
-					LOGGER.info("Response: {}", responseData);
+		InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, request.getMid(), "POST",
+				requestJson);
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET",
+				request.getStatusType());
+		LOGGER.debug("Outbound log created successfully for Complaint : {}", fullUrl);
 
-					helper.updateOutboundLogResponse(outboundLog, responseData);
+		try {
+			LOGGER.info("Calling external API: {}", fullUrl);
+			Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
+			String responseData = responseMap.get("data");
+			LOGGER.info("Response: {}", responseData);
 
-					Map<String, Object> dataMap = objectMapper.readValue(responseData,
-							new TypeReference<Map<String, Object>>() {
-							});
+			helper.updateOutboundLogResponse(outboundLog, responseData);
 
-					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(""));
-					}
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
 
-					ViewAllComplaintsResponse responseWrapper = objectMapper.convertValue(dataMap,
-							ViewAllComplaintsResponse.class);
-					GeneralResp generalResp = responseWrapper.getGeneralResp();
+			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(""));
+			}
 
-					String status = generalResp.getStatus();
-					LOGGER.info("Current Complaint ReOpen Status: {}", status);
+			ViewAllComplaintsTicketsResponse responseWrapper = objectMapper.convertValue(dataMap,
+					ViewAllComplaintsTicketsResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
 
-					helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
-					String saveComplaint = mapperHelper.saveAllComplaints(responseWrapper, reqId, txnId);
-					//LOGGER.info("Complaint ReOpen data saved successfully for Count History: {}", saveComplaintHistory);
+			String status = generalResp.getStatus();
+			LOGGER.info("Current Complaint ReOpen Status: {}", status);
 
-					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");
-				}
- 	}
-	
-	
+			String saveComplaint = mapperHelper.saveAllComplaints(responseWrapper, reqId, txnId);
+			LOGGER.info("Complaint ReOpen data saved successfully for Count History: {}", saveComplaint);
+
+			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/MasterDataServiceImpl.java

@@ -1,6 +1,7 @@
 // java
 package com.billpaymentservice.bbps.serviceImpl;
 
+import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -12,10 +13,8 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
-import com.billpaymentservice.bbps.dto.CustomerParamGroupsDTO;
-
 import com.billpaymentservice.bbps.dto.CustomParamDTO;
-
+import com.billpaymentservice.bbps.dto.CustomerParamGroupsDTO;
 import com.billpaymentservice.bbps.dto.GeneralResp;
 import com.billpaymentservice.bbps.dto.MasterApiResponse;
 import com.billpaymentservice.bbps.dto.ResponseModel;
@@ -35,6 +34,7 @@ import com.billpaymentservice.bbps.dto.response.CustomerParamGroupsResponse;
 import com.billpaymentservice.bbps.dto.response.DispositionResponse;
 import com.billpaymentservice.bbps.dto.response.PlanResponse;
 import com.billpaymentservice.bbps.dto.response.PlaneCategoriesResponse;
+import com.billpaymentservice.bbps.dto.response.TicketDispositionResponse;
 import com.billpaymentservice.bbps.entites.BharatConnectMaster;
 import com.billpaymentservice.bbps.entites.BillerCategoryWise;
 import com.billpaymentservice.bbps.entites.BillerDetails;
@@ -42,6 +42,7 @@ import com.billpaymentservice.bbps.entites.CustomParam;
 import com.billpaymentservice.bbps.entites.DispositionDetails;
 import com.billpaymentservice.bbps.entites.InboundTraceLog;
 import com.billpaymentservice.bbps.entites.OutboundTraceLog;
+import com.billpaymentservice.bbps.entites.TicketDispositionDetails;
 import com.billpaymentservice.bbps.exception.CustomException;
 import com.billpaymentservice.bbps.repository.BharatConnectMasterRepository;
 import com.billpaymentservice.bbps.repository.BillerDataRepository;
@@ -50,6 +51,7 @@ import com.billpaymentservice.bbps.repository.DispositionRepository;
 import com.billpaymentservice.bbps.repository.InboundTraceLogRepository;
 import com.billpaymentservice.bbps.repository.MerchantRepository;
 import com.billpaymentservice.bbps.repository.OutboundTraceLogRepository;
+import com.billpaymentservice.bbps.repository.TicketDispositionRepository;
 import com.billpaymentservice.bbps.service.MasterDataService;
 import com.billpaymentservice.bbps.util.BBPSConstant;
 import com.billpaymentservice.bbps.util.BillerMapperHelper;
@@ -71,6 +73,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 	private MerchantRepository merchantRegisterRepo;
 	private HttpClientApi httpClientApi;
 	private final DispositionRepository dispositionRepository;
+	
 	private final Helper helper;
 	private final BillerDataRepository billerDataRespository;
 	private final HttpService httpService;
@@ -95,6 +98,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 		this.outboundTraceLogRepository = outboundTraceLogRepository;
 		this.mapperHelper = mapperHelper;
 		this.customParamReposiotory = customParamReposiotory;
+		
 
 	}
 
@@ -123,7 +127,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>>() {
@@ -195,6 +199,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 			BillerDetails entity = mapper.map(responseWrapper.getBillerDAO(), BillerDetails.class);
 			EntityRelationshipUtil.linkBillerRelationships(entity);// linking nesting entity foreign key
 			helper.saveOrUpdateBillerData(entity);
+
 			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
 					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
 			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
@@ -295,7 +300,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);
 
@@ -674,4 +679,58 @@ public class MasterDataServiceImpl implements MasterDataService {
 		}
 	}
 
+	@Override
+	public ResponseModel getTicketDispositions(DispositionRequest dispositionDetailRequest) {
+		LOGGER.info("Fetching Ticket Disposition Details for ReqId={} and MID={}", dispositionDetailRequest.getReqId(),
+				dispositionDetailRequest.getMid());
+
+		String txnID = helper.generateTxnId(15);
+		String apiName = "GetTicketDispositionDetails";
+		String requestId = dispositionDetailRequest.getReqId();
+		helper.validateMerchant(dispositionDetailRequest.getMid());
+		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName,
+				dispositionDetailRequest.getMid(), "GET", "N/A");
+
+		String fullUrl = masterRegisterUrl + BBPSConstant.TICKET_DISPOSTION_URL;
+		OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
+		LOGGER.info("Calling external API: {}", fullUrl);
+		Map<String, String> responseMap = httpService.getRequest(fullUrl);
+		String responseData = responseMap.get("data");
+
+		helper.updateOutboundLogResponse(outboundLog, responseData);
+		try {
+
+			ObjectMapper objectMapper = new ObjectMapper();
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+			if (!dataMap.containsKey("generalResp")) {
+				helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
+				throw new CustomException(String.valueOf(dataMap.get("message")), // message
+						String.valueOf(dataMap.get("status")), // status
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
+						String.valueOf(dataMap.get("remarks")));
+			}
+
+			TicketDispositionResponse responseWrapper = objectMapper.convertValue(dataMap,
+					TicketDispositionResponse.class);
+			System.out.println(responseWrapper);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+			ModelMapper mapper = new ModelMapper();
+			mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
+			mapperHelper.saveTicketDisoptionDetails(responseWrapper.getDispositionsList(), requestId, txnID);
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+
+			return responseModel;
+		} catch (JsonProcessingException e) {
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
+			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+			throw new CustomException("Invalid JSON received from API");
+		}
+	}
+
 }