810 lines
40 KiB
Java
810 lines
40 KiB
Java
package com.billpaymentservice.bbps.serviceImpl;
|
|
|
|
import java.util.Map;
|
|
import java.util.Optional;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
import org.springframework.beans.factory.annotation.Value;
|
|
|
|
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.BillFetchByBillIdRequest;
|
|
import com.billpaymentservice.bbps.dto.request.BillFetchByClientIdRequest;
|
|
import com.billpaymentservice.bbps.dto.request.BillValidateByClientIdRequest;
|
|
import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
|
|
import com.billpaymentservice.bbps.dto.request.FetchBillValidatestRequest;
|
|
import com.billpaymentservice.bbps.dto.response.BillDataResponse;
|
|
import com.billpaymentservice.bbps.dto.response.FetchBillResponse;
|
|
import com.billpaymentservice.bbps.dto.response.FetchBillValidateResponse;
|
|
import com.billpaymentservice.bbps.dto.sentRequest.FetchBillForwardRequest;
|
|
import com.billpaymentservice.bbps.dto.sentRequest.FetchBillValidatestForwardRequest;
|
|
import com.billpaymentservice.bbps.entites.BillInitiate;
|
|
import com.billpaymentservice.bbps.entites.BillMaster;
|
|
import com.billpaymentservice.bbps.entites.BillValidation;
|
|
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.repository.BillInitateRepository;
|
|
import com.billpaymentservice.bbps.repository.BillMasterRepository;
|
|
import com.billpaymentservice.bbps.repository.BillValidationRepository;
|
|
import com.billpaymentservice.bbps.repository.InboundTraceLogRepository;
|
|
import com.billpaymentservice.bbps.repository.OutboundTraceLogRepository;
|
|
import com.billpaymentservice.bbps.service.AgentService;
|
|
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.fasterxml.jackson.core.JsonProcessingException;
|
|
import com.fasterxml.jackson.core.type.TypeReference;
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
|
|
@Service
|
|
public class AgentServiceImpl implements AgentService {
|
|
|
|
@Value("${agent.data.url}")
|
|
private String agentDtaUrl;
|
|
|
|
private final RestClient restClient;
|
|
private final HttpService httpService;
|
|
private final Helper helper;
|
|
private final BharatConnectMasterRepository beneficiaryDetailsRepository;
|
|
private final BillerMapperHelper mapperHelper;
|
|
private final BillMasterRepository billMasterRepository;
|
|
private final BillInitateRepository billIntiateRepository;
|
|
private final BillValidationRepository billValidationRepository;
|
|
private static final Logger LOGGER = LoggerFactory.getLogger(AgentServiceImpl.class);
|
|
|
|
// Reusable ObjectMapper instance
|
|
private final ObjectMapper objectMapper = new ObjectMapper()
|
|
.setSerializationInclusion(JsonInclude.Include.NON_NULL);
|
|
|
|
public AgentServiceImpl(RestClient restClient, HttpService httpService, Helper helper,
|
|
BharatConnectMasterRepository beneficiaryDetailsRepository,
|
|
InboundTraceLogRepository inboundTraceLogRepository, OutboundTraceLogRepository outboundTraceLogRepository,
|
|
BillMasterRepository billMasterRepository, BillInitateRepository billIntiateRepository,
|
|
BillerMapperHelper mapperHelper,BillValidationRepository billValidationRepository) {
|
|
this.restClient = restClient;
|
|
this.httpService = httpService;
|
|
this.helper = helper;
|
|
this.beneficiaryDetailsRepository = beneficiaryDetailsRepository;
|
|
this.billMasterRepository = billMasterRepository;
|
|
this.billIntiateRepository = billIntiateRepository;
|
|
this.mapperHelper = mapperHelper;
|
|
this.billValidationRepository=billValidationRepository;
|
|
}
|
|
|
|
@Override
|
|
public ResponseModel initiateBillFetch(FetchBillRequest fetchBillRequest) {
|
|
|
|
String apiName = BBPSConstant.API_INITIATE_BILL_FETCH;
|
|
String requestId = fetchBillRequest.getReqId();
|
|
String mid = fetchBillRequest.getMid();
|
|
LOGGER.info("[{}] START | reqId={} | mid={} | billerId={}", apiName, requestId, mid,
|
|
fetchBillRequest.getBillerId());
|
|
String txnId = helper.generateTxnId(15);
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_INTI;
|
|
fetchBillRequest.setClientReqId(txnId);
|
|
FetchBillForwardRequest forwardReq = mapperHelper.fetchBillForwardRequestMap(fetchBillRequest);
|
|
|
|
String forwardJson = helper.convertObjectToJson(forwardReq);
|
|
String requestJson = helper.convertObjectToJson(fetchBillRequest);
|
|
|
|
InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnId, apiName, fetchBillRequest.getMid(),
|
|
BBPSConstant.HTTP_POST, requestJson);
|
|
helper.validateMerchant(mid);
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, requestId, apiName, fullUrl,
|
|
BBPSConstant.HTTP_POST, forwardJson);
|
|
LOGGER.debug("Outbound log created successfully for txnId: {} and reqId: {}", txnId, requestId);
|
|
|
|
BillMaster billMaster =new BillMaster();
|
|
billMaster.setReqId(fetchBillRequest.getReqId());
|
|
billMaster.setInitiatorTxnId(txnId);
|
|
billMaster.setMid(fetchBillRequest.getMid());
|
|
billMaster.setClientUserId(fetchBillRequest.getClientUserId());
|
|
billMasterRepository.save(billMaster);
|
|
try {
|
|
LOGGER.info("[{}] Calling external API | URL={}", apiName, fullUrl);
|
|
Map<String, String> responseMap = httpService.postRequest(fullUrl, forwardJson,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
|
|
helper.updateOutboundLogResponse(outboundLog, responseData);
|
|
LOGGER.debug("Response received from BBPS: {}", responseData);
|
|
|
|
Map<String, Object> dataMap = objectMapper.readValue(responseData,
|
|
new TypeReference<Map<String, Object>>() {
|
|
});
|
|
if (!dataMap.containsKey(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.INVALID_RESPONSE);
|
|
LOGGER.warn("Invalid response received 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")));
|
|
}
|
|
|
|
LOGGER.info("BillMaster saved for billId: {}", billMaster.getBillId());
|
|
|
|
FetchBillResponse fetchBillResponse = objectMapper.convertValue(dataMap, FetchBillResponse.class);
|
|
GeneralResp generalResponse = fetchBillResponse.getGenericResponse();
|
|
helper.updateInboundLogSuccess(inboundLog, responseData, generalResponse.getStatus());
|
|
|
|
|
|
BillFetchByBillIdRequest billFetchByBillIdRequest = new BillFetchByBillIdRequest();
|
|
billFetchByBillIdRequest.setBillId(fetchBillResponse.getBillId());
|
|
billFetchByBillIdRequest.setMid(fetchBillRequest.getMid());
|
|
billFetchByBillIdRequest.setReqId(requestId);
|
|
LOGGER.info("Waiting for 2 seconds before fetching bill by ID...");
|
|
try {
|
|
Thread.sleep((long) BBPSConstant.BILL_FETCH_DELAY_MS);
|
|
} catch (InterruptedException e) {
|
|
Thread.currentThread().interrupt();
|
|
LOGGER.warn("Thread interrupted during delay: {}", e.getMessage());
|
|
}
|
|
|
|
LOGGER.info("Calling internal method Fetching bill by ID: {}", billFetchByBillIdRequest.getBillId());
|
|
LOGGER.info("[{}] END | reqId={} | status={}", apiName, requestId, generalResponse.getStatus());
|
|
return fetchBillById(billFetchByBillIdRequest, inboundLog);
|
|
} catch (JsonProcessingException e) {
|
|
LOGGER.error("JSON Parsing Error: {}", e.getMessage(), e);
|
|
helper.updateInboundLogFailure(inboundLog, e.getMessage(), BBPSConstant.JSON_ERROR);
|
|
// Use standardized user-facing message and status, keep internal details in remarks
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM, BBPSConstant.FAILED_STATUS, BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
}
|
|
|
|
public ResponseModel fetchBillById(BillFetchByBillIdRequest billFetchByBillIdRequest, InboundTraceLog inboundLog) {
|
|
LOGGER.info("Fetching bill by BILLID for request ID={} and MID={}", billFetchByBillIdRequest.getReqId(),
|
|
billFetchByBillIdRequest.getMid());
|
|
String apiName = BBPSConstant.API_FETCH_BILL_BY_ID;
|
|
String txnId = helper.generateTxnId(15);
|
|
String reqId = billFetchByBillIdRequest.getReqId();
|
|
String billId = billFetchByBillIdRequest.getBillId();
|
|
String userId = billFetchByBillIdRequest.getClientUserId();
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID + billFetchByBillIdRequest.getBillId();
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, BBPSConstant.HTTP_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,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
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(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.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")));
|
|
}
|
|
|
|
BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
|
|
GeneralResp generalResp = responseWrapper.getGenericResponse();
|
|
|
|
|
|
BillMaster
|
|
existingbill=billMasterRepository.findByInitiatorTxnId(
|
|
inboundLog.getTxnId());
|
|
String status = generalResp.getStatus();
|
|
LOGGER.info("Current Bill Status: {}", status);
|
|
|
|
helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
|
|
mapperHelper.saveOrUpdateBillData(responseWrapper, billFetchByBillIdRequest, txnId, reqId,billFetchByBillIdRequest.getClientUserId(), existingbill);
|
|
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(), BBPSConstant.JSON_ERROR);
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM, BBPSConstant.FAILED_STATUS, BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ResponseModel fetchBillById(BillFetchByBillIdRequest billFetchByBillIdRequest) {
|
|
|
|
String apiName = BBPSConstant.API_FETCH_BILL_BY_ID;
|
|
String reqId = billFetchByBillIdRequest.getReqId();
|
|
String billId = billFetchByBillIdRequest.getBillId();
|
|
String mid = billFetchByBillIdRequest.getMid();
|
|
String userId = billFetchByBillIdRequest.getClientUserId();
|
|
String requestJson = helper.convertObjectToJson(billFetchByBillIdRequest);
|
|
LOGGER.info("[{}] START | reqId={} | mid={} | billId={} | userId={}", apiName, reqId, mid, billId, userId);
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID + billFetchByBillIdRequest.getBillId();
|
|
String txnId = helper.generateTxnId(15);
|
|
InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, billFetchByBillIdRequest.getMid(),
|
|
BBPSConstant.HTTP_GET, requestJson);
|
|
LOGGER.info("Initiating {} API for billId={} and reqId={}", apiName, billId, reqId);
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, BBPSConstant.HTTP_GET,
|
|
null);
|
|
try {
|
|
|
|
LOGGER.info("Calling external BBPS API for FetchBillById, URL={}", fullUrl);
|
|
Map<String, String> responseMap = httpService.getRequest(fullUrl,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
LOGGER.info("Response received from BBPS for billId={} : {}", billId, responseData);
|
|
|
|
helper.updateOutboundLogResponse(outboundLog, responseData);
|
|
|
|
Map<String, Object> dataMap = objectMapper.readValue(responseData,
|
|
new TypeReference<Map<String, Object>>() {
|
|
});
|
|
|
|
if (!dataMap.containsKey(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.INVALID_RESPONSE);
|
|
LOGGER.warn("Invalid response structure received for billId={} | Response={}", billId, responseData);
|
|
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();
|
|
ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
|
|
Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
|
|
|
|
// update inbound log success and persist bill data
|
|
helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
|
|
//mapperHelper.saveOrUpdateBillData(responseWrapper, billFetchByBillIdRequest, txnId, reqId, userId);
|
|
LOGGER.info("Bill data saved successfully for billId={} | Status={}", billId, generalResp.getStatus());
|
|
LOGGER.info("[{}] END | reqId={} | status={}", apiName, reqId, generalResp.getStatus());
|
|
return responseModel;
|
|
|
|
}
|
|
|
|
catch (JsonProcessingException e) {
|
|
LOGGER.error("Error parsing responseData JSON for billId={} : {}", billId, e.getMessage(), e);
|
|
helper.updateInboundLogFailure(inboundLog, e.getMessage(), BBPSConstant.JSON_ERROR);
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM, BBPSConstant.FAILED_STATUS, BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ResponseModel initiateBillValidate(FetchBillValidatestRequest fetchBillValidateRequest) {
|
|
String apiName = BBPSConstant.API_INITIATE_BILL_VALIDATE;
|
|
String reqId = fetchBillValidateRequest.getReqId();
|
|
String mid = fetchBillValidateRequest.getMid();
|
|
LOGGER.info("[{}] START | reqId={} | mid={} | billerId={}", apiName, fetchBillValidateRequest.getReqId(), mid,
|
|
fetchBillValidateRequest.getBillerId());
|
|
String txnId = helper.generateTxnId(15);
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILLER_VALIDATE_URL;
|
|
fetchBillValidateRequest.setClientReqId(txnId);
|
|
|
|
FetchBillValidatestForwardRequest forwardReq = mapperHelper
|
|
.fetchBillValidatestForwardRequest(fetchBillValidateRequest);
|
|
|
|
String forwardJson = helper.convertObjectToJson(forwardReq);
|
|
|
|
String requestJson = helper.convertObjectToJson(fetchBillValidateRequest);
|
|
|
|
InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, fetchBillValidateRequest.getMid(),
|
|
BBPSConstant.HTTP_POST, requestJson);
|
|
helper.validateMerchant(fetchBillValidateRequest.getMid());
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, BBPSConstant.HTTP_POST,
|
|
forwardJson);
|
|
LOGGER.debug("Outbound log created successfully for txnId: {} and reqId: {}", txnId, reqId);
|
|
|
|
BillValidation billValidation = new BillValidation();
|
|
billValidation.setReqId(fetchBillValidateRequest.getReqId());
|
|
billValidation.setInitiatorTxnId(txnId);
|
|
billValidation.setMid(fetchBillValidateRequest.getMid());
|
|
billValidation.setClientUserId(fetchBillValidateRequest.getClientUserId());
|
|
billValidationRepository.save(billValidation);
|
|
|
|
try {
|
|
LOGGER.info("[{}] Calling external API | URL={}", apiName, fullUrl);
|
|
Map<String, String> responseMap = httpService.postRequest(fullUrl, forwardJson,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
|
|
helper.updateOutboundLogResponse(outboundLog, responseData);
|
|
LOGGER.debug("Response received from BBPS: {}", responseData);
|
|
|
|
Map<String, Object> dataMap = objectMapper.readValue(responseData,
|
|
new TypeReference<Map<String, Object>>() {
|
|
});
|
|
if (!dataMap.containsKey(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.INVALID_RESPONSE);
|
|
LOGGER.warn("Invalid response received 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")));
|
|
}
|
|
|
|
FetchBillResponse fetchBillResponse = objectMapper.convertValue(dataMap, FetchBillResponse.class);
|
|
GeneralResp generalResponse = fetchBillResponse.getGenericResponse();
|
|
helper.updateInboundLogSuccess(inboundLog, responseData, generalResponse.getStatus());
|
|
|
|
BillFetchByBillIdRequest billFetchByBillIdRequest = new BillFetchByBillIdRequest();
|
|
billFetchByBillIdRequest.setBillId(fetchBillResponse.getBillId());
|
|
billFetchByBillIdRequest.setMid(fetchBillValidateRequest.getMid());
|
|
billFetchByBillIdRequest.setReqId(reqId);
|
|
LOGGER.info("Waiting for 2 seconds before fetching bill by ID...");
|
|
try {
|
|
Thread.sleep((long) BBPSConstant.BILL_VALIDATE_DELAY_MS);
|
|
} catch (InterruptedException e) {
|
|
Thread.currentThread().interrupt();
|
|
LOGGER.warn("Thread interrupted during delay: {}", e.getMessage());
|
|
}
|
|
LOGGER.info("Calling internal method Fetching bill by ID: {}", billFetchByBillIdRequest.getBillId());
|
|
LOGGER.info("[{}] END | reqId={} | status={}", apiName, reqId, generalResponse.getStatus());
|
|
return BillvaidateByBillId(billFetchByBillIdRequest, inboundLog);
|
|
} catch (JsonProcessingException e) {
|
|
LOGGER.error("JSON Parsing Error: {}", e.getMessage(), e);
|
|
helper.updateInboundLogFailure(inboundLog, e.getMessage(), BBPSConstant.JSON_ERROR);
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM, BBPSConstant.FAILED_STATUS ,BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
}
|
|
|
|
public ResponseModel BillvaidateByBillId(BillFetchByBillIdRequest billRequest, InboundTraceLog inboundLog) {
|
|
{
|
|
LOGGER.info("Validating bill by BILLID for request ID={} and MID={}", billRequest.getReqId(),
|
|
billRequest.getMid());
|
|
String apiName = BBPSConstant.API_FETCH_BILL_BY_ID;
|
|
String txnId = helper.generateTxnId(15);
|
|
String reqId = billRequest.getReqId();
|
|
String billId = billRequest.getBillId();
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_ID_URL + billRequest.getBillId();
|
|
|
|
BillValidation
|
|
billValidation=billValidationRepository.findByInitiatorTxnId(
|
|
inboundLog.getTxnId());
|
|
billValidation.setCheckerTxnId(txnId);
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl,
|
|
BBPSConstant.HTTP_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,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
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(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.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);
|
|
mapperHelper.saveBillValidation(responseWrapper, billRequest, txnId,billValidation);
|
|
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(), BBPSConstant.JSON_ERROR);
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM, BBPSConstant.FAILED_STATUS, BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ResponseModel initiateBillValidateByBillId(BillFetchByBillIdRequest billRequest) {
|
|
String apiName = BBPSConstant.API_FETCH_BILL_BY_ID;
|
|
String reqId = billRequest.getReqId();
|
|
String billId = billRequest.getBillId();
|
|
String mid = billRequest.getMid();
|
|
String requestJson = helper.convertObjectToJson(billRequest);
|
|
LOGGER.info("[{}] START | reqId={} | mid={} | billId={}", apiName, billRequest, mid, billId);
|
|
String txnId = helper.generateTxnId(15);
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_ID_URL + billRequest.getBillId();
|
|
|
|
LOGGER.info("Initiating {} API for billId={} and reqId={}", apiName, billId, reqId);
|
|
|
|
InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, billRequest.getMid(),
|
|
BBPSConstant.HTTP_GET, requestJson);
|
|
helper.validateMerchant(billRequest.getMid());
|
|
try {
|
|
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl,
|
|
BBPSConstant.HTTP_GET, null);
|
|
LOGGER.info("Calling external BBPS API for ValidateByBillId, URL={}", fullUrl);
|
|
|
|
Map<String, String> responseMap = httpService.getRequest(fullUrl,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
LOGGER.info("Response received from BBPS for billId={} : {}", billId, responseData);
|
|
|
|
helper.updateOutboundLogResponse(outboundLog, responseData);
|
|
|
|
Map<String, Object> dataMap = objectMapper.readValue(responseData,
|
|
new com.fasterxml.jackson.core.type.TypeReference<Map<String, Object>>() {
|
|
});
|
|
|
|
if (!dataMap.containsKey(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.INVALID_RESPONSE);
|
|
LOGGER.warn("Invalid response structure received for billId={} | Response={}", billId, responseData);
|
|
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();
|
|
|
|
helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
|
|
//mapperHelper.saveBillValidation(responseWrapper, billRequest, txnId);
|
|
LOGGER.info("Bill validation saved successfully for billId: {}", billId);
|
|
LOGGER.info("[{}] END | reqId={} | status={}", apiName, reqId, generalResp.getStatus());
|
|
return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
|
|
Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
|
|
|
|
} catch (com.fasterxml.jackson.core.JsonProcessingException e) {
|
|
LOGGER.error("Error parsing ValidateByBillId JSON: {}", e.getMessage(), e);
|
|
helper.updateInboundLogFailure(inboundLog, e.getMessage(), BBPSConstant.JSON_ERROR);
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM,BBPSConstant.FAILED_STATUS, BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public ResponseModel fetchBillValidateByClientReqId(BillValidateByClientIdRequest billValidateByClientIdRequest) {
|
|
|
|
String apiName = BBPSConstant.API_FETCH_BILL_VALIDATE_BY_CLIENT_ID;
|
|
String reqId = billValidateByClientIdRequest.getReqId();
|
|
String clientReqId = billValidateByClientIdRequest.getClientReqId();
|
|
String mid = billValidateByClientIdRequest.getMid();
|
|
String txnId = helper.generateTxnId(15);
|
|
String requestJson = helper.convertObjectToJson(billValidateByClientIdRequest);
|
|
LOGGER.info("[{}] START | reqId={} | mid={} | clientReqId={}", apiName, reqId, mid,
|
|
billValidateByClientIdRequest.getClientReqId());
|
|
InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName,
|
|
billValidateByClientIdRequest.getMid(), BBPSConstant.HTTP_GET, requestJson);
|
|
|
|
helper.validateMerchant(billValidateByClientIdRequest.getMid());
|
|
Optional<BillInitiate> billInitiate = billIntiateRepository.findByReqId(clientReqId);
|
|
if (billInitiate.isEmpty()) {
|
|
new CustomException(
|
|
BBPSConstant.NO_BILL_FOUND, // message // status
|
|
BBPSConstant.FAILED_STATUS,
|
|
BBPSConstant.HTTP_NOT_FOUND, // statusCode
|
|
"Bill not found in database for given clientReqId"
|
|
);
|
|
}
|
|
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_BY_CLIENT_REQ_ID + billInitiate.get().getTxnId();
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, BBPSConstant.HTTP_GET,
|
|
null);
|
|
|
|
try {
|
|
LOGGER.info("Calling BBPS API FetchBillValidateByClientReqId, URL={}", fullUrl);
|
|
Map<String, String> responseMap = httpService.getRequest(fullUrl,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
|
|
helper.updateOutboundLogResponse(outboundLog, responseData);
|
|
|
|
Map<String, Object> dataMap = objectMapper.readValue(responseData,
|
|
new TypeReference<Map<String, Object>>() {
|
|
});
|
|
|
|
if (!dataMap.containsKey(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.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();
|
|
|
|
helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
|
|
LOGGER.info("[{}] END | reqId={} | status={}", apiName, reqId, generalResp.getStatus());
|
|
return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
|
|
Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
|
|
|
|
} catch (JsonProcessingException e) {
|
|
helper.updateInboundLogFailure(inboundLog, e.getMessage(), BBPSConstant.JSON_ERROR);
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM, BBPSConstant.FAILED_STATUS, BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ResponseModel fetchBillByClientReqId(BillFetchByClientIdRequest billFetchByClientIdRequest) {
|
|
|
|
String apiName = BBPSConstant.API_FETCH_BILL_BY_CLIENT_ID;
|
|
String reqId = billFetchByClientIdRequest.getReqId();
|
|
String clientReqId = billFetchByClientIdRequest.getClientReqId();
|
|
String mid = billFetchByClientIdRequest.getMid();
|
|
String requestJson = helper.convertObjectToJson(billFetchByClientIdRequest);
|
|
LOGGER.info("[{}] START | reqId={} | mid={} | clientReqId={}", apiName, reqId, mid,
|
|
billFetchByClientIdRequest.getClientReqId());
|
|
String txnId = helper.generateTxnId(15);
|
|
InboundTraceLog inboundLog = helper.createInboundLog(reqId, txnId, apiName, billFetchByClientIdRequest.getMid(),
|
|
BBPSConstant.HTTP_GET, requestJson);
|
|
helper.validateMerchant(billFetchByClientIdRequest.getMid());
|
|
|
|
Optional<BillInitiate> billInitiate = billIntiateRepository.findByReqId(clientReqId);
|
|
if (billInitiate.isEmpty()) {
|
|
throw new CustomException(
|
|
BBPSConstant.NO_BILL_FOUND, // message // status
|
|
BBPSConstant.FAILED_STATUS,
|
|
BBPSConstant.HTTP_NOT_FOUND, // statusCode
|
|
"Bill not found in database for given clientReqId"
|
|
);
|
|
}
|
|
String fullUrl = agentDtaUrl + BBPSConstant.BILL_VALIDATE_BY_CLIENT_REQ_ID + billInitiate.get().getTxnId();
|
|
|
|
OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, BBPSConstant.HTTP_GET,
|
|
null);
|
|
|
|
try {
|
|
LOGGER.info("[{}] Calling external API | URL={} | reqId={}", apiName, fullUrl, reqId);
|
|
Map<String, String> responseMap = httpService.getRequest(fullUrl,
|
|
helper.buildHeaders(beneficiaryDetailsRepository.findByOrgId(BBPSConstant.ORG_ID)));
|
|
String responseData = responseMap.get(BBPSConstant.RESPONSE_DATA_KEY);
|
|
|
|
helper.updateOutboundLogResponse(outboundLog, responseData);
|
|
|
|
Map<String, Object> dataMap = objectMapper.readValue(responseData,
|
|
new TypeReference<Map<String, Object>>() {
|
|
});
|
|
|
|
if (!dataMap.containsKey(BBPSConstant.RESPONSE_GENERIC_KEY)) {
|
|
helper.updateInboundLogFailure(inboundLog, responseData, BBPSConstant.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();
|
|
|
|
helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
|
|
LOGGER.info("[{}] END | reqId={} | status={}", apiName, reqId, generalResp.getStatus());
|
|
return new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
|
|
Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
|
|
|
|
} catch (JsonProcessingException e) {
|
|
helper.updateInboundLogFailure(inboundLog, e.getMessage(), BBPSConstant.JSON_ERROR);
|
|
throw new CustomException(BBPSConstant.MSG_INVALID_JSON_FROM_UPSTREAM, BBPSConstant.FAILED_STATUS, BBPSConstant.INVALID_JSON_STATUS_CODE, e.getMessage());
|
|
}
|
|
}
|
|
|
|
/*
|
|
* @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"); } }
|
|
* }
|
|
*/
|
|
|
|
@Override
|
|
public ResponseModel processBillFetchCallback(BillDataResponse billDataResponse) {
|
|
LOGGER.info("Recived Call Back from billDataResponse: {}", billDataResponse);
|
|
if (billDataResponse.getGenericResponse().getStatusCode().equals(BBPSConstant.SUCCESS_CODE_STR)) {
|
|
} else {
|
|
LOGGER.info("Bill Fetch Callback Failed with Status: {}",
|
|
billDataResponse.getGenericResponse().getStatus());
|
|
}
|
|
return new ResponseModel(BBPSConstant.CALLBACK_RECEIVED_SUCCESS, BBPSConstant.SUCCESS_CODE_STR,
|
|
BBPSConstant.HTTP_OK_INT, "");
|
|
}
|
|
|
|
@Override
|
|
public ResponseModel processBillValidateCallback(FetchBillValidateResponse billValidateResponse) {
|
|
LOGGER.info("Recived Call Back from FetchBillValidateResponse: {}", billValidateResponse);
|
|
if (billValidateResponse.getGenericResponse().getStatusCode().equals(BBPSConstant.SUCCESS_CODE_STR)) {
|
|
} else {
|
|
LOGGER.info("Bill Fetch Callback Failed with Status: {}",
|
|
billValidateResponse.getGenericResponse().getStatus());
|
|
}
|
|
return new ResponseModel(BBPSConstant.CALLBACK_RECEIVED_SUCCESS, BBPSConstant.SUCCESS_CODE_STR,
|
|
BBPSConstant.HTTP_OK_INT, "");
|
|
}
|
|
}
|