03-11-25

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

@@ -8,6 +8,7 @@ import org.springframework.web.bind.annotation.*;
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
 import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
+import com.billpaymentservice.bbps.dto.request.FetchBillValidatestRequest;
 import com.billpaymentservice.bbps.service.AgentService;
 
 @RestController
@@ -49,5 +50,26 @@ public class AgentController {
     	    ResponseModel response = agentService.fetchBillById(billFetchByBillIdRequest);
     	    return ResponseEntity.ok(response);
     	}
+    
+    /**
+	 * Fetches bill details validate from external BBPS service
+	 */
+	@PostMapping(value = "/requestBillValidate", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> requestBillValidate(
+			@Validated @RequestBody FetchBillValidatestRequest fetchBillValidateRequest) {
+
+		ResponseModel response = agentService.initiateBillValidate(fetchBillValidateRequest);
+		return ResponseEntity.ok(response);
+	}
+
+	/**
+	 * Fetches bill details by bill Id from external BBPS service
+	 */
+	@PostMapping(value = "/requestBillValidateByBillId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> requestBillByBillId(@Validated @RequestBody BillFetchByBillIdRequest billRequest) {
+
+		ResponseModel response = agentService.initiateBillValidateByBillId(billRequest);
+		return ResponseEntity.ok(response);
+	}
 
 }

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

@@ -1,35 +1,22 @@
 package com.billpaymentservice.bbps.controller;
 
-import java.util.List;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
-
-import com.billpaymentservice.bbps.dto.MasterApiResponse;
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
 import com.billpaymentservice.bbps.dto.request.ContactMasterRequest;
 import com.billpaymentservice.bbps.dto.request.CustomParamRequest;
+import com.billpaymentservice.bbps.dto.request.MasterCategoryRequest;
 import com.billpaymentservice.bbps.dto.request.MasterRequest;
-import com.billpaymentservice.bbps.dto.request.MerchantRequestModel;
-import com.billpaymentservice.bbps.dto.response.BillerDataResponse;
-import com.billpaymentservice.bbps.dto.response.BillerResponse;
-import com.billpaymentservice.bbps.dto.response.ContactMasterResponse;
-import com.billpaymentservice.bbps.dto.response.CustomParamResp;
 import com.billpaymentservice.bbps.service.MasterDataService;
 
-import jakarta.servlet.http.HttpServletRequest;
-
 @RequestMapping("/masterData")
 @RestController
 public class MasterDataController {
@@ -41,34 +28,86 @@ public class MasterDataController {
 	public MasterDataController(MasterDataService masterDataService) {
 		this.masterDataService = masterDataService;
 	}
-    /**Get Details of the biller by billId **/
+
+	/** Get Details of the biller by billId **/
 	@PostMapping(value = "/getBillerDetails", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
-	public ResponseEntity<ResponseModel> getBillerDetails(@Validated @RequestBody BillerDetailRequest billerDetailRequest) {
+	public ResponseEntity<ResponseModel> getBillerDetails(
+			@Validated @RequestBody BillerDetailRequest billerDetailRequest) {
 
 		log.info("Received biller details request for billerId: {}", billerDetailRequest.getBillerId());
 
-	    return ResponseEntity.ok(masterDataService.getBillerByBillerId(billerDetailRequest));
+		return ResponseEntity.ok(masterDataService.getBillerByBillerId(billerDetailRequest));
 	}
-    /**Get Master Contact**/
+
+	/** Get Master Contact **/
 	@PostMapping(value = "/getContactMasterResponse", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
 	public ResponseEntity<ResponseModel> getContactMaster(
-			@Validated @RequestBody ContactMasterRequest  contactMasterRequest ) {
+			@Validated @RequestBody ContactMasterRequest contactMasterRequest) {
 
-	    return ResponseEntity.ok(masterDataService.getContactMaster(contactMasterRequest));
+		return ResponseEntity.ok(masterDataService.getContactMaster(contactMasterRequest));
 	}
-	
+
-   /** Get CustomerParam by billerId.The parameter is different from the data we are getting in the billerDetail **/
+	/**
+	 * Get CustomerParam by billerId.The parameter is different from the data we are
+	 * getting in the billerDetail
+	 **/
 	@PostMapping(value = "/getCustomerParamDetails", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
 	public ResponseEntity<ResponseModel> getBillerDetails(
 			@Validated @RequestBody CustomParamRequest customerParamRequest) {
 
-		log.info("Received biller details request for billerId: {}",customerParamRequest.getBillerId() );
+		log.info("Received biller details request for billerId: {}", customerParamRequest.getBillerId());
 
-	    return ResponseEntity.ok(masterDataService.getCustomerParamByBillerId(customerParamRequest));
+		return ResponseEntity.ok(masterDataService.getCustomerParamByBillerId(customerParamRequest));
 	}
+
+	/**
+	 * Get All Master Data .The parameter is different from the data we are getting
+	 * in the MasterRequest
+	 **/
 	@PostMapping("/getAllMastersData")
 	public ResponseModel fetchMasterData(@Validated @RequestBody MasterRequest masterRequest) {
 		return masterDataService.getMasterData(masterRequest);
 	}
 
+	/** POST Master Category Wise API Fetch Category Wise from BBPS URL **/
+	@PostMapping(value = "/getMasterCategoryWise", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getMasterDataCategoryWise(
+			@Validated @RequestBody MasterCategoryRequest masterRequest) {
+		return ResponseEntity.ok(masterDataService.fetchMasterDataCategoryWise(masterRequest));
+	}
+
+	/** POST Customer Param Groups API Fetch Category Wise from BBPS URL **/
+	@PostMapping(value = "/customerParamGroups", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getCustomerParamGroup(
+			@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchCustomerParamGroup(requestModel));
+	}
+
+	/**
+	 * POST Fetch All AMount Options By Biller Id API Fetch Category Wise from BBPS
+	 * URL
+	 **/
+	@PostMapping(value = "/fetchAllAmountOptionsByBillerId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchAllMasterAmountOptionsByBillerId(
+			@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchAllMasterAmountOption(requestModel));
+	}
+
+	/**
+	 * POST Fetch All AMount Options By Biller Id API Fetch Category Wise from BBPS
+	 * URL
+	 **/
+	@PostMapping(value = "/fetchPlanCategories", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchPlanCategories(@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchPlanCategorie(requestModel));
+	}
+	
+	/**
+	 * POST Fetch Initiating Channel API Fetch Category Wise from BBPS
+	 * URL
+	 **/
+	@PostMapping(value = "/initiatingChannel", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> initiatingChannel(@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchInitiatingChannel(requestModel));
+	}
 }

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

@@ -1,21 +1,19 @@
 package com.billpaymentservice.bbps.dto;
 
+import java.util.UUID;
+
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import lombok.ToString;
 
 @Getter
 @Setter
-@AllArgsConstructor
 @NoArgsConstructor
-@ToString
+@AllArgsConstructor
-public class GeneralResponse {
+public class ChannelDTO {
 
-	private String statusCode;
+	private UUID channelId; // Machine-generated Unique ID assigned internally
-	private String status;
+	private String channelName;
-	private String message;
-	private String remarks;
 
 }

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

@@ -8,12 +8,14 @@ import java.util.List;
 @Setter
 public class GroupDTO {
 
-    private String name;
+	private String groupId;
+	
+	private String name;
 
-    private String input;
+	private String input;
 
-    private List<String> params;
+	private List<String> params;
 
-    // 🔁 Nested child groups
+	// 🔁 Nested child groups
-    private List<GroupDTO> groups;
+	private List<GroupDTO> groups;
 }

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

@@ -11,11 +11,8 @@ import lombok.Setter;
 @AllArgsConstructor
 @NoArgsConstructor
 public class BillFetchByBillIdRequest extends BaseClass {
-    
+
 	@NotNull
 	private String billId;
-	private String tenantId;                
-	private String digiledgeKey;           
-	private String agentId;   
 
 }

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

@@ -0,0 +1,30 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import com.billpaymentservice.bbps.dto.CustomerParamsRequest;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class FetchBillValidatestRequest extends BaseClass {
+
+	@NotNull
+	private String billerId; // Alphanumeric, Unique ID assigned by NPCI
+	@NotNull
+	private String billerName; // String, Name of the biller
+	@NotNull
+	private String billerCategory; // String, Category of the biller
+	@NotNull
+	private String customerMobNo; // String, Mobile of the Customer
+
+	// Optional Fields
+	private String macAddress; // Alphanumeric MAC Address of the Agent Server
+	//private String clientReqId; // String, Unique id provided by the client
+	private CustomerParamsRequest customerParamsRequest; // Customer parameters for identifying the bill
+}

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

@@ -0,0 +1,24 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MasterCategoryRequest extends BaseClass {
+
+	private String billerName;
+
+	@NotNull
+	private String category;
+
+	private Integer pageStart = 0;
+
+	private Integer pageEnd = 10;
+
+}

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

@@ -1,15 +1,12 @@
 package com.billpaymentservice.bbps.dto.request;
 
-import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
 import lombok.Getter;
-import lombok.NoArgsConstructor;
+
 import lombok.Setter;
+
 @Getter
 @Setter
-@AllArgsConstructor
+
-@NoArgsConstructor
 public class MasterRequest extends BaseClass {
-    @NotNull
+
-	private String tenantId;
 }

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

@@ -0,0 +1,29 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.AmountOptionDTO;
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class AmountOptionsResponse {
+
+	// Root element, no parent
+	@JsonProperty("amountOptions")
+	private Boolean amountOptions;
+
+	@JsonProperty("amountOptionDAOS")
+	private List<AmountOptionDTO> amountOptionDAOS;
+
+	@JsonProperty("generalResp")
+	private GeneralResp generalResp;
+}

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

@@ -6,8 +6,8 @@ import com.billpaymentservice.bbps.dto.AdditionalInfoBill;
 import com.billpaymentservice.bbps.dto.BillerResponseBill;
 import com.billpaymentservice.bbps.dto.CustomerParamDAO;
 import com.billpaymentservice.bbps.dto.GeneralResp;
-import com.billpaymentservice.bbps.dto.GeneralResponse;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;
@@ -20,21 +20,22 @@ import lombok.Setter;
 @NoArgsConstructor
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class BillDataResponse {
-	
-	    private GeneralResp genericResponse;
-	    private String billId;
-	    private String refId;
-	    private String billerId;
-	    private String status;
-	    private String actionType;
-	    private String userId;
-	    
-	    private BillerResponseBill billerResponse;   // nested object
-	    private List<AdditionalInfoBill> additionalInfo;  // array of objects
-	    private List<CustomerParamDAO> customerParams;   // array of objects
 
-	    private String creationDate;
+	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
-	    private String modifiedDate;
+	private GeneralResp genericResponse;
-	    private long createdEpochDate;
+	private String billId;
-	    private long modifiedEpochDate;
+	private String refId;
+	private String billerId;
+	private String status;
+	private String actionType;
+	private String userId;
+
+	private BillerResponseBill billerResponse; // nested object
+	private List<AdditionalInfoBill> additionalInfo; // array of objects
+	private List<CustomerParamDAO> customerParams; // array of objects
+
+	private String creationDate;
+	private String modifiedDate;
+	private long createdEpochDate;
+	private long modifiedEpochDate;
 }

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

@@ -2,7 +2,7 @@ package com.billpaymentservice.bbps.dto.response;
 
 import java.util.List;
 
-import com.billpaymentservice.bbps.dto.GeneralResponse;
+import com.billpaymentservice.bbps.dto.GeneralResp;
 import com.billpaymentservice.bbps.dto.MasterCategoryBillerResponse;
 
 import lombok.AllArgsConstructor;
@@ -20,7 +20,7 @@ public class BillerResponse {
 	private int pageSize;
 	private long totalElements;
 	private int totalPages;
-	private GeneralResponse generalResp;
+	private GeneralResp generalResp;
 	private List<MasterCategoryBillerResponse> billerResp;
 
 }

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

@@ -0,0 +1,25 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.ChannelDTO;
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ChannelsListResponse {
+
+	private List<ChannelDTO> channelList;
+
+	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+	private GeneralResp genericResp;
+
+}

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

@@ -0,0 +1,22 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import com.billpaymentservice.bbps.dto.CustomerParamGroupsDTO;
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class CustomerParamGroupsResponse {
+
+	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+	private GeneralResp generalResp;
+
+	private CustomerParamGroupsDTO customerParamGroupResp;
+}

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

@@ -1,6 +1,6 @@
 package com.billpaymentservice.bbps.dto.response;
 
-import com.billpaymentservice.bbps.dto.GeneralResponse;
+import com.billpaymentservice.bbps.dto.GeneralResp;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
 import lombok.AllArgsConstructor;
@@ -14,7 +14,7 @@ import lombok.Setter;
 @NoArgsConstructor
 public class FetchBillResponse {
 	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
-	private GeneralResponse genericResponse;
+	private GeneralResp genericResponse;
     private String billId;
     private String refId;
     private String billerId;

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

@@ -0,0 +1,34 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class FetchBillValidatestResponse {
+
+	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+	private GeneralResp genericResponse;
+	private String billId;
+	private String refId;
+	private String billerId;
+	private String status;
+	private String actionType;
+	private String userId;
+	private String billerResponse;
+	private String additionalInfo;
+	private String customerParams;
+	private String planInfoDaos;
+	private String creationDate;
+	private String modifiedDate;
+	private long createdEpochDate;
+	private long modifiedEpochDate;
+
+}

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

@@ -0,0 +1,24 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class PlaneCategoriesResponse {
+
+	private List<String> categoryRespList;
+
+	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+	private GeneralResp generalResp;
+
+}

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

@@ -3,6 +3,7 @@ package com.billpaymentservice.bbps.service;
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
 import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
+import com.billpaymentservice.bbps.dto.request.FetchBillValidatestRequest;
 
 public interface AgentService {
 
@@ -10,4 +11,8 @@ public interface AgentService {
 
 	public ResponseModel fetchBillById(BillFetchByBillIdRequest billFetchByBillIdRequest);
 
+	public ResponseModel initiateBillValidate(FetchBillValidatestRequest fetchBillValidateRequest);
+
+	public ResponseModel initiateBillValidateByBillId(BillFetchByBillIdRequest billRequest);
+
 }

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

@@ -1,8 +1,10 @@
 package com.billpaymentservice.bbps.service;
+
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
 import com.billpaymentservice.bbps.dto.request.ContactMasterRequest;
 import com.billpaymentservice.bbps.dto.request.CustomParamRequest;
+import com.billpaymentservice.bbps.dto.request.MasterCategoryRequest;
 import com.billpaymentservice.bbps.dto.request.MasterRequest;
 import com.billpaymentservice.bbps.dto.request.MerchantRequestModel;
 import jakarta.servlet.http.HttpServletRequest;
@@ -13,10 +15,18 @@ public interface MasterDataService {
 
 	public ResponseModel getMasterData(MasterRequest masterRequest);
 
-	public ResponseModel fetchMasterDataCategoryWise(MerchantRequestModel requestModel, String category, int pageStart, int pageEnd);
-
 	public ResponseModel getCustomerParamByBillerId(CustomParamRequest customerParamRequest);
 
 	public ResponseModel getContactMaster(ContactMasterRequest contactMasterRequest);
 
+	public ResponseModel fetchMasterDataCategoryWise(MasterCategoryRequest masterRequest);
+
+	public ResponseModel fetchCustomerParamGroup(BillerDetailRequest requestModel);
+
+	public ResponseModel fetchAllMasterAmountOption(BillerDetailRequest requestModel);
+
+	public ResponseModel fetchPlanCategorie(BillerDetailRequest requestModel);
+
+	public ResponseModel fetchInitiatingChannel(BillerDetailRequest requestModel);
+
 }

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

@@ -1,13 +1,21 @@
 package com.billpaymentservice.bbps.serviceImpl;
 
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestClient;
+
 import com.billpaymentservice.bbps.dto.GeneralResp;
-import com.billpaymentservice.bbps.dto.GeneralResponse;
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
 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.BillerDataResponse;
 import com.billpaymentservice.bbps.dto.response.FetchBillResponse;
+import com.billpaymentservice.bbps.dto.response.FetchBillValidatestResponse;
 import com.billpaymentservice.bbps.entites.BharatConnectMaster;
 import com.billpaymentservice.bbps.exception.CustomException;
 import com.billpaymentservice.bbps.repository.BharatConnectMasterRepository;
@@ -18,163 +26,270 @@ 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 lombok.RequiredArgsConstructor;
+
 import lombok.extern.slf4j.Slf4j;
 
-import java.util.HashMap;
-import java.util.Map;
-
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.http.*;
-import org.springframework.stereotype.Service;
-import org.springframework.web.client.RestClient;
-import org.springframework.web.servlet.function.ServerRequest.Headers;
-
 @Service
 @Slf4j
 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;
-     
-     public AgentServiceImpl(RestClient restClient,HttpService httpService,Helper helper, BharatConnectMasterRepository beneficiaryDetailsRepository) {
-    	 this.restClient=restClient;
-    	 this.httpService=httpService;
-    	 this.helper=helper;
-    	 this.beneficiaryDetailsRepository=beneficiaryDetailsRepository;
-     }
-     
-      @Override
-      public ResponseModel initiateBillFetch(FetchBillRequest fetchBillRequest) {
-          String url = agentDtaUrl+BBPSConstant.BILL_FETCH_INTI;
-          System.out.println(url);
-          
-          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);
 
-          
+	private final RestClient restClient;
+	private final HttpService httpService;
+	private final Helper helper;
+	private final BharatConnectMasterRepository beneficiaryDetailsRepository;
 
-          ResponseModel responseModel = new ResponseModel();
+	public AgentServiceImpl(RestClient restClient, HttpService httpService, Helper helper,
+			BharatConnectMasterRepository beneficiaryDetailsRepository) {
+		this.restClient = restClient;
+		this.httpService = httpService;
+		this.helper = helper;
+		this.beneficiaryDetailsRepository = beneficiaryDetailsRepository;
+	}
 
-          try {
+	@Override
-              ObjectMapper objectMapper = new ObjectMapper();
+	public ResponseModel initiateBillFetch(FetchBillRequest fetchBillRequest) {
-              objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		String url = agentDtaUrl + BBPSConstant.BILL_FETCH_INTI;
+		System.out.println(url);
 
-              // ✅ Convert request to JSON
+		BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
-              String json = objectMapper.writeValueAsString(fetchBillRequest);
 
-              // ✅ Call the API using httpService
+		HttpHeaders headers = new HttpHeaders();
-              Map<String, String> responseMap = httpService.postRequest(url, json, headers);
+		headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
-              String responseData = responseMap.get("data");
+		headers.set("agentId", headersData.getAgentId());
+		headers.set("tenantId", headersData.getTenantId());
+		headers.setContentType(MediaType.APPLICATION_JSON);
 
-              log.info("📦 Bill Fetch API Response: {}", responseData);
+		ResponseModel responseModel = new ResponseModel();
-
-              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
-              FetchBillResponse fetchBillResponse = objectMapper.convertValue(dataMap, FetchBillResponse.class);
-              GeneralResponse generalResponse = fetchBillResponse.getGenericResponse();
-              //
-              //start a new thread here 
-              helper.startPolling(fetchBillResponse, 
-            		    res -> {
-            		        BillFetchByBillIdRequest pollReq = new BillFetchByBillIdRequest();
-            		        pollReq.setBillId(res.getBillId());
-            		        return fetchBillById(pollReq);
-            		    },
-            		    3,  // interval in seconds
-            		    15  // total time in seconds
-            		);
-              
-              
-
-              // ✅ Build final ResponseModel
-              responseModel = new ResponseModel(
-                      generalResponse.getMessage(),
-                      generalResponse.getStatus(),
-                      Integer.parseInt(generalResponse.getStatusCode()),
-                      fetchBillResponse
-              );
-
-          } 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 fetchBillById(BillFetchByBillIdRequest billFetchByBillIdRequest) {
-		
-		  String billId = billFetchByBillIdRequest.getBillId();
-			String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID+billId;
-			System.out.print(fullUrl);
-			
-			 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);
-	          
-			  Map<String, String> responseMap = httpService.getRequest(fullUrl,headers);
-			  String responseData = responseMap.get("data");
-			  log.info("data is :{}", responseData);
-			
 
+		try {
 			ObjectMapper objectMapper = new ObjectMapper();
+			objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 
-			try {
+			// ✅ Convert request to JSON
-				Map<String, Object> dataMap = objectMapper.readValue(responseData,
+			String json = objectMapper.writeValueAsString(fetchBillRequest);
-						new TypeReference<Map<String, Object>>() {
-						});
-				if (!dataMap.containsKey("genericResponse")) {
-					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")) );
-				}
-		
-				BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
-				
-				GeneralResp generalResp = responseWrapper.getGenericResponse();
-				
-				ResponseModel responseModel=new ResponseModel( generalResp.getMessage(),
-				        generalResp.getStatus(),
-				        Integer.parseInt(generalResp.getStatusCode()),
-				        responseWrapper);
-				
-				return responseModel;
 
-			} catch (JsonProcessingException e) {
+			// ✅ Call the API using httpService
-				log.error("Error parsing responseData JSON: {}", e.getMessage());
+			Map<String, String> responseMap = httpService.postRequest(url, json, headers);
-				throw new CustomException("Invalid JSON received from API");
+			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
+			FetchBillResponse fetchBillResponse = objectMapper.convertValue(dataMap, FetchBillResponse.class);
+			GeneralResp generalResponse = fetchBillResponse.getGenericResponse();
+			//
+			// start a new thread here
+			helper.startPolling(fetchBillResponse, res -> {
+				BillFetchByBillIdRequest pollReq = new BillFetchByBillIdRequest();
+				pollReq.setBillId(res.getBillId());
+				return fetchBillById(pollReq);
+			}, 3, // interval in seconds
+					15 // total time in seconds
+			);
+
+			// ✅ Build final ResponseModel
+			responseModel = new ResponseModel(generalResponse.getMessage(), generalResponse.getStatus(),
+					Integer.parseInt(generalResponse.getStatusCode()), fetchBillResponse);
+
+		} 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 fetchBillById(BillFetchByBillIdRequest billFetchByBillIdRequest) {
+
+		String billId = billFetchByBillIdRequest.getBillId();
+		String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID + billId;
+		System.out.print(fullUrl);
+
+		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);
+
+		Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
+		String responseData = responseMap.get("data");
+		log.info("data is :{}", responseData);
+
+		ObjectMapper objectMapper = new ObjectMapper();
+
+		try {
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+			if (!dataMap.containsKey("genericResponse")) {
+				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")));
+			}
+
+			BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
+
+			GeneralResp generalResp = responseWrapper.getGenericResponse();
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			return responseModel;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		}
+
+	}
+
+	@Override
+	public ResponseModel initiateBillValidate(FetchBillValidatestRequest fetchBillValidateRequest) {
+
+		ResponseModel responseModel = new ResponseModel();
+		try {
+			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 (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 {
+
+			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 (Exception e) {
+			log.error("❌ Exception in initiateBillFetch(): {}", e.getMessage(), e);
+			responseModel.setStatus("500");
+			responseModel.setMessage("Exception occurred");
+			responseModel.setData(e.getMessage());
+		}
+
+		return responseModel;
+
+	}
 
 }

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

@@ -124,11 +124,12 @@ public class HttpService {
                     .headers(h -> h.addAll(headers))
                     .retrieve()
                     .toEntity(String.class);
+            
 
             response.put("respCode", String.valueOf(restResponse.getStatusCode().value()));
             response.put("data", restResponse.getBody());
 
-            log.info("✅ GET Response: {}", restResponse.getStatusCode());
+            log.info("✅ GET Response: {}", restResponse.getBody());
 
         } catch (HttpClientErrorException | HttpServerErrorException httpException) {
             log.error("❌ HTTP Error: {}", httpException.getMessage(), httpException);

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

@@ -1,41 +1,34 @@
 package com.billpaymentservice.bbps.serviceImpl;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 
 import org.modelmapper.ModelMapper;
 import org.modelmapper.convention.MatchingStrategies;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 
-import com.billpaymentservice.bbps.dto.BillerDTO;
 import com.billpaymentservice.bbps.dto.GeneralResp;
 import com.billpaymentservice.bbps.dto.MasterApiResponse;
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
 import com.billpaymentservice.bbps.dto.request.ContactMasterRequest;
 import com.billpaymentservice.bbps.dto.request.CustomParamRequest;
+import com.billpaymentservice.bbps.dto.request.MasterCategoryRequest;
 import com.billpaymentservice.bbps.dto.request.MasterRequest;
-import com.billpaymentservice.bbps.dto.request.MerchantRequestModel;
+import com.billpaymentservice.bbps.dto.response.AmountOptionsResponse;
 import com.billpaymentservice.bbps.dto.response.BillerDataResponse;
 import com.billpaymentservice.bbps.dto.response.BillerResponse;
-import com.billpaymentservice.bbps.dto.response.CategoryResponse;
+import com.billpaymentservice.bbps.dto.response.ChannelsListResponse;
-import com.billpaymentservice.bbps.dto.response.ContactMasterResponse;
 import com.billpaymentservice.bbps.dto.response.CustomParamResp;
-import com.billpaymentservice.bbps.entites.BBPSMerchantValidation;
+import com.billpaymentservice.bbps.dto.response.CustomerParamGroupsResponse;
-import com.billpaymentservice.bbps.entites.BillPayment;
+import com.billpaymentservice.bbps.dto.response.PlaneCategoriesResponse;
+import com.billpaymentservice.bbps.entites.BharatConnectMaster;
 import com.billpaymentservice.bbps.entites.BillerDetails;
-import com.billpaymentservice.bbps.exception.AppException;
 import com.billpaymentservice.bbps.exception.CustomException;
+import com.billpaymentservice.bbps.repository.BharatConnectMasterRepository;
 import com.billpaymentservice.bbps.repository.BillerDataRepository;
-import com.billpaymentservice.bbps.repository.MerchantRepository;
 import com.billpaymentservice.bbps.service.MasterDataService;
 import com.billpaymentservice.bbps.util.BBPSConstant;
 import com.billpaymentservice.bbps.util.Helper;
@@ -43,8 +36,6 @@ import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
-import jakarta.servlet.http.HttpServletRequest;
-
 @Service
 public class MasterDataServiceImpl implements MasterDataService {
 
@@ -53,37 +44,29 @@ public class MasterDataServiceImpl implements MasterDataService {
 	@Value("${master.data.url}")
 	private String masterRegisterUrl;
 
-	private MerchantRepository merchantRegisterRepo;
-	private HttpClientApi httpClientApi;
 	private Helper helper;
-	private  final BillerDataRepository billerDataRespository;
+	private final BillerDataRepository billerDataRespository;
-	
+	private final BharatConnectMasterRepository beneficiaryDetailsRepository;
 
 	private static final Logger log = LoggerFactory.getLogger(MasterDataServiceImpl.class);
 	private final HttpService httpService;
 	private final ObjectMapper objectMapper = new ObjectMapper();
-	
+
 	// Inject HttpService
-	public MasterDataServiceImpl(MerchantRepository merchantRegisterRepo,
+	public MasterDataServiceImpl(BharatConnectMasterRepository beneficiaryDetailsRepository, HttpService httpService,
-            HttpService httpService,
+			Helper helper, BillerDataRepository billerDataRespository) {
-            HttpClientApi httpClientApi,
+		this.beneficiaryDetailsRepository = beneficiaryDetailsRepository;
-            Helper helper,
+		this.httpService = httpService;
-            BillerDataRepository billerDataRespository
+		this.helper = helper;
-           ) {
+		this.billerDataRespository = billerDataRespository;
-            this.merchantRegisterRepo = merchantRegisterRepo;
+
-            this.httpService = httpService;
+	}
-            this.httpClientApi = httpClientApi;
+
-            this.helper = helper;
-            this.billerDataRespository=billerDataRespository;
-          
-             
-                                               }
 	@Override
 	public ResponseModel getBillerByBillerId(BillerDetailRequest billerDetailRequest) {
-        
-		String billerId = billerDetailRequest.getBillerId();
-		String fullUrl = masterRegisterUrl + BBPSConstant.BILLER_DATA_FETCH_URL+billerId;
 
+		String billerId = billerDetailRequest.getBillerId();
+		String fullUrl = masterRegisterUrl + BBPSConstant.BILLER_DATA_FETCH_URL + billerId;
 
 		Map<String, String> responseMap = httpService.getRequest(fullUrl);
 		String responseData = responseMap.get("data");
@@ -96,35 +79,29 @@ public class MasterDataServiceImpl implements MasterDataService {
 					new TypeReference<Map<String, Object>>() {
 					});
 			if (!dataMap.containsKey("generalResp")) {
-				throw new CustomException(String.valueOf(dataMap.get("message")),  // message
+				throw new CustomException(String.valueOf(dataMap.get("message")), // message
-					    String.valueOf(dataMap.get("status")),   // status
+						String.valueOf(dataMap.get("status")), // status
-					    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
-					    String.valueOf(dataMap.get("remarks")) );
+						String.valueOf(dataMap.get("remarks")));
 			}
-	
+
 			BillerDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillerDataResponse.class);
 			GeneralResp generalResp = responseWrapper.getGeneralResp();
 			ModelMapper mapper = new ModelMapper();
 			mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
-		    BillerDetails entity = mapper.map(responseWrapper.getBillerDAO(), BillerDetails.class);
+			BillerDetails entity = mapper.map(responseWrapper.getBillerDAO(), BillerDetails.class);
 
 			System.out.println(entity);
-			
-			  if (entity != null) 
-			  { 
-				 billerDataRespository.save(entity); 
-			  }
-			  else {
-			  LOGGER.warn("No biller found in response to save."); 
-			  }
-			 
 
-			
+			if (entity != null) {
-			ResponseModel responseModel=new ResponseModel( generalResp.getMessage(),
+				billerDataRespository.save(entity);
-			        generalResp.getStatus(),
+			} else {
-			        Integer.parseInt(generalResp.getStatusCode()),
+				LOGGER.warn("No biller found in response to save.");
-			        responseWrapper);
+			}
-			
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
 			return responseModel;
 
 		} catch (JsonProcessingException e) {
@@ -136,142 +113,327 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel getMasterData(MasterRequest masterRequest) {
-	    LOGGER.info("Request DTO: {}", masterRequest);
+		LOGGER.info("Request DTO: {}", masterRequest);
 
-	    String fullUrl = masterRegisterUrl + BBPSConstant.MASTER_CATEGORY_URL + masterRequest.getTenantId();
+		try {
-	    LOGGER.info("Calling external API: {}", fullUrl);
+			BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
-
+			log.info("ResPONSE" + headersData);
-	    Map<String, String> responseMap = httpService.getRequest(fullUrl);
+			if (headersData == null) {
-	    String responseData = responseMap.get("data");
+				ResponseModel responseModel = new ResponseModel("Tenant Id Is Null", "Not Found",
-	    LOGGER.info("Response Data: {}", responseData);
+						BBPSConstant.BADREQUEST, headersData);
-
+				return responseModel;
-	    ObjectMapper objectMapper = new ObjectMapper();
-
-	    try {
-	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
-
-	        // ✅ Same check as in getBillerByBillerId()
-	        if (!dataMap.containsKey("generalResp")) {
-	            throw new CustomException(
-	                    String.valueOf(dataMap.get("message")),   // message
-	                    String.valueOf(dataMap.get("status")),    // status
-	                    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode
-	                    String.valueOf(dataMap.get("remarks"))    // remarks
-	            );
-	        }
-
-	        MasterApiResponse responseWrapper = objectMapper.convertValue(dataMap, MasterApiResponse.class);
-	        GeneralResp generalResp = responseWrapper.getGeneralResp();
-	        
-
-	        ResponseModel responseModel = new ResponseModel(
-	                generalResp.getMessage(),
-	                generalResp.getStatus(),
-	                Integer.parseInt(generalResp.getStatusCode()),
-	                responseWrapper
-	        );
-
-	        return responseModel;
-
-	    } catch (JsonProcessingException e) {
-	        log.error("Error parsing responseData JSON: {}", e.getMessage());
-	        throw new CustomException("Invalid JSON received from API");
-	    }
-	}
-
-
-	@Override
-	public ResponseModel fetchMasterDataCategoryWise(MerchantRequestModel requestModel,
-			String category, int pageStart, int pageEnd) {
-		LOGGER.info("Fetching Master Data Category-wise for MID={}, Category={}, PageStart={}, PageEnd={}",
-				requestModel.getMid(), category, pageStart, pageEnd);
-
-		BBPSMerchantValidation merchantValidation = merchantRegisterRepo.findByMid(requestModel.getMid());
-		BillerResponse responseModel = new BillerResponse();
-		// if Start merchant validations
-		if (Optional.ofNullable(merchantValidation).isPresent()) {
-			// if Start merchant active check
-			if (merchantValidation.isActive()) {
-
-				LOGGER.info("mid Value: " + requestModel.getMid() + " secret Value: " + requestModel.getSecretKey()
-						+ "txt Value: " + requestModel);
-				// 2️⃣ Build API URL
-				String fullUrl = String.format("%s%s?category=%s&page=%d&pagesize=%d", masterRegisterUrl,
-						BBPSConstant.BILLER_URL, category, pageStart, pageEnd);
-
-				LOGGER.info("Calling Master API: {}", fullUrl);
-				HashMap<String, Object> response = httpClientApi.getRequestForPaymentStatus(fullUrl);
-
-				LOGGER.info("BBPS bank response data: " + response.get("data") + " code: " + response.get("respCode"));
-				// if Start merchant cehck response code
-
-				if (response.get("respCode") != null && response.get("respCode").toString().contains("200")) {
-					LOGGER.info("Response -: " + response.get("data"));
-					String jsonData = response.get("data").toString();
-					//responseModel = responseParser.billerResponse(jsonData);
-
-					LOGGER.info("kkk" + responseModel.toString());
-					// 5️⃣ Prepare API response model
-
-				} else {
-					LOGGER.warn("Unexpected response code: " + response.get("respCode"));
-
-				}
-
-			} else {
-				LOGGER.info("Merchant Not Active for mid - " + requestModel.getMid());
-				throw new AppException("Merchant Not Active", BBPSConstant.CODE_MERCHANT_INACTIVE);
 			}
-		} else {
+			String fullUrl = masterRegisterUrl + BBPSConstant.MASTER_CATEGORY_URL + headersData.getTenantId();
-			LOGGER.info("Merchant Not Valid for mid - " + requestModel.getMid());
+			LOGGER.info("Calling external API: {}", fullUrl);
-			throw new AppException("Merchant Not Valid", BBPSConstant.CODE_MERCHANT_INVALID);
-		}
-		 return new ResponseModel();
 
+			Map<String, String> responseMap = httpService.getRequest(fullUrl);
+			String responseData = responseMap.get("data");
+			LOGGER.info("Response Data: {}", responseData);
+
+			ObjectMapper objectMapper = new ObjectMapper();
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			// ✅ Same check as in getBillerByBillerId()
+			if (!dataMap.containsKey("generalResp")) {
+				throw new CustomException(String.valueOf(dataMap.get("message")), // message
+						String.valueOf(dataMap.get("status")), // status
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode
+						String.valueOf(dataMap.get("remarks")) // remarks
+				);
+			}
+
+			MasterApiResponse responseWrapper = objectMapper.convertValue(dataMap, MasterApiResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			return responseModel;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		}
 	}
 
 	@Override
 	public ResponseModel getCustomerParamByBillerId(CustomParamRequest customerParamRequest) {
-		String billerId = customerParamRequest.getBillerId();
-	   String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMPARAM_URL+billerId;
-
-
-		Map<String, String> responseMap = httpService.getRequest(fullUrl);
-		String responseData = responseMap.get("data");
-		log.info("data is :{}", responseData);
-
-		ObjectMapper objectMapper = new ObjectMapper();
 
 		try {
+
+			String billerId = customerParamRequest.getBillerId();
+			String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMPARAM_URL + billerId;
+
+			Map<String, String> responseMap = httpService.getRequest(fullUrl);
+			String responseData = responseMap.get("data");
+			log.info("data is :{}", responseData);
+
+			ObjectMapper objectMapper = new ObjectMapper();
+
 			Map<String, Object> dataMap = objectMapper.readValue(responseData,
 					new TypeReference<Map<String, Object>>() {
 					});
 			if (!dataMap.containsKey("generalResp")) {
-				throw new CustomException(String.valueOf(dataMap.get("message")),  // message
+				throw new CustomException(String.valueOf(dataMap.get("message")), // message
-					    String.valueOf(dataMap.get("status")),   // status
+						String.valueOf(dataMap.get("status")), // status
-					    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode (int)
-					    String.valueOf(dataMap.get("remarks")) );
+						String.valueOf(dataMap.get("remarks")));
 			}
-	
+
 			CustomParamResp responseWrapper = objectMapper.convertValue(dataMap, CustomParamResp.class);
 			GeneralResp generalResp = responseWrapper.getGeneralResp();
-			
+
-			ResponseModel responseModel=new ResponseModel( generalResp.getMessage(),
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
-			        generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
-			        Integer.parseInt(generalResp.getStatusCode()),
+
-			        responseWrapper);
-			
 			return responseModel;
 		} catch (JsonProcessingException e) {
 			log.error("Error parsing responseData JSON: {}", e.getMessage());
 			throw new CustomException("Invalid JSON received from API");
 		}
-		
+
 	}
 
 	@Override
 	public ResponseModel getContactMaster(ContactMasterRequest contactMasterRequest) {
-		
+
 		return new ResponseModel();
 	}
+
+	@Override
+	public ResponseModel fetchMasterDataCategoryWise(MasterCategoryRequest masterRequest) {
+		LOGGER.info("Fetching Master Data Category-wise " + masterRequest);
+
+		try {
+
+			String validateMerchant = helper.validateMerchant(masterRequest);
+
+			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
+				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
+				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
+			}
+
+			String fullUrl = String.format("%s%s?billerName=%s&category=%s&page=%d&pagesize=%d", masterRegisterUrl,
+					BBPSConstant.BILLER_URL, masterRequest.getBillerName(), masterRequest.getCategory(),
+					masterRequest.getPageStart(), masterRequest.getPageEnd());
+
+			Map<String, String> responseMap = httpService.getRequest(fullUrl);
+			String responseData = responseMap.get("data");
+			LOGGER.info("Response Data: {}", responseData);
+
+			ObjectMapper objectMapper = new ObjectMapper();
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			// ✅ Same check as in getBillerByBillerId()
+			if (!dataMap.containsKey("generalResp")) {
+				throw new CustomException(String.valueOf(dataMap.get("message")), // message
+						String.valueOf(dataMap.get("status")), // status
+						Integer.parseInt(String.valueOf(dataMap.get("statusCode"))), // statusCode
+						String.valueOf(dataMap.get("remarks")) // remarks
+				);
+			}
+
+			BillerResponse responseWrapper = objectMapper.convertValue(dataMap, BillerResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			return responseModel;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		}
+
+	}
+
+	@Override
+	public ResponseModel fetchCustomerParamGroup(BillerDetailRequest requestModel) {
+		LOGGER.info("Fetching Master Data Category-wise for MID={}", requestModel.getMid());
+
+		try {
+
+			String validateMerchant = helper.validateMerchant(requestModel);
+
+			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
+				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
+				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
+			}
+
+			String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMER_PARAM_GROUP + requestModel.getBillerId();
+			// LOGGER.info("Calling Master API: {}", fullUrl);
+
+			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
+			String responseData = apiResponse.get("data").toString();
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("generalResp")) {
+				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")));
+			}
+
+			CustomerParamGroupsResponse responseWrapper = objectMapper.convertValue(dataMap,
+					CustomerParamGroupsResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			return responseModel;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		}
+
+	}
+
+	@Override
+	public ResponseModel fetchAllMasterAmountOption(BillerDetailRequest requestModel) {
+		LOGGER.info("Fetching Master Data Amount List for MID={}", requestModel.getMid());
+		try {
+			String validateMerchant = helper.validateMerchant(requestModel);
+
+			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
+				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
+				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
+			}
+
+			String fullUrl = masterRegisterUrl + BBPSConstant.AMOUNT_OPTIONS + requestModel.getBillerId();
+			// LOGGER.info("Calling Master API: {}", fullUrl);
+
+			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
+			log.info("Response" + apiResponse);
+			String responseData = apiResponse.get("data").toString();
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("generalResp")) {
+				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")));
+			}
+
+			AmountOptionsResponse responseWrapper = objectMapper.convertValue(dataMap, AmountOptionsResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			return responseModel;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		} catch (CustomException e) {
+			LOGGER.error("Custom Exception: {}", e.getMessage());
+			throw e; // Rethrow custom exceptions to be handled by the controller
+		}
+	}
+
+	@Override
+	public ResponseModel fetchPlanCategorie(BillerDetailRequest requestModel) {
+		LOGGER.info("Fetching Master Data Amount List for MID={}", requestModel.getMid());
+		try {
+			String validateMerchant = helper.validateMerchant(requestModel);
+
+			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
+				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
+				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
+			}
+
+			String fullUrl = masterRegisterUrl + BBPSConstant.PLAN_CATEGORIES + requestModel.getBillerId();
+			// LOGGER.info("Calling Master API: {}", fullUrl);
+
+			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
+			log.info("Response" + apiResponse);
+			String responseData = apiResponse.get("data").toString();
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("generalResp")) {
+				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")));
+			}
+
+			PlaneCategoriesResponse responseWrapper = objectMapper.convertValue(dataMap, PlaneCategoriesResponse.class);
+			GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			return responseModel;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		} catch (CustomException e) {
+			LOGGER.error("Custom Exception: {}", e.getMessage());
+			throw e; // Rethrow custom exceptions to be handled by the controller
+		}
+	}
+
+	@Override
+	public ResponseModel fetchInitiatingChannel(BillerDetailRequest requestModel) {
+		LOGGER.info("Fetching Initiating Channel List for MID={}", requestModel.getMid());
+		try {
+			String validateMerchant = helper.validateMerchant(requestModel);
+
+			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
+				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
+				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
+			}
+
+			String fullUrl = masterRegisterUrl + BBPSConstant.INITIATING_CHANNEL;
+			LOGGER.info("Calling Master API: {}", fullUrl);
+
+			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
+			log.info("Response" + apiResponse);
+			String responseData = apiResponse.get("data").toString();
+
+			Map<String, Object> dataMap = objectMapper.readValue(responseData,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+			if (!dataMap.containsKey("generalResp")) {
+				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")));
+			}
+
+			ChannelsListResponse responseWrapper = objectMapper.convertValue(dataMap, ChannelsListResponse.class);
+			GeneralResp generalResp = responseWrapper.getGenericResp();
+
+			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
+					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
+
+			return responseModel;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		} catch (CustomException e) {
+			LOGGER.error("Custom Exception: {}", e.getMessage());
+			throw e; // Rethrow custom exceptions to be handled by the controller
+		}
+	}
+
 }

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

@@ -12,7 +12,6 @@ import org.springframework.http.MediaType;
 import org.springframework.stereotype.Service;
 
 import com.billpaymentservice.bbps.dto.GeneralResp;
-import com.billpaymentservice.bbps.dto.GeneralResponse;
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
 import com.billpaymentservice.bbps.dto.request.BillPaymentRequest;

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

@@ -8,6 +8,7 @@ public class BBPSConstant {
 	public static final Long SCHEDULER_CODE = 222L;
 	public static final Long PENDING_CODE = 211L;
 	public static final Long FRAUD_CODE = 1001L;
+	public static final int BADREQUEST = 400;
 
 	public static final String SUCCESS_STATUS = "success";
 	public static final String FAILED_STATUS = "failed";
@@ -25,12 +26,19 @@ public class BBPSConstant {
 
 	public static final String BILLER_URL = "/billers";
 	public static final String MASTER_CATEGORY_URL = "/categories-master?tenantId=";
-	
+
-	public static final String BILLER_DATA_FETCH_URL="/billersById?billerId=";
+	public static final String BILLER_DATA_FETCH_URL = "/billersById?billerId=";
-	public static final String CUSTOMPARAM_URL="/customerParam?billerId=";
+	public static final String CUSTOMPARAM_URL = "/customerParam?billerId=";
-	public static final String BILL_FETCH_INTI="/couapp/bills/fetch";
+	public static final String BILL_FETCH_INTI = "/couapp/bills/fetch";
-	public static final String BILL_FETCH_BY_ID="/couapp/bills/fetch/byId?billId=";
+	public static final String BILL_FETCH_BY_ID = "/couapp/bills/fetch/byId?billId=";
-	public static final String PAYMENT_URL="/agent/bills/payment";
+	public static final String PAYMENT_URL = "/agent/bills/payment";
-	public static final String CHECK_TRANSACTION_URL="/transactions/payment/byTxnId?txnId=";
+	public static final String CHECK_TRANSACTION_URL = "/transactions/payment/byTxnId?txnId=";
+	public static final String CUSTOMER_PARAM_GROUP = "/customerParamGroup?billerId=";
+	public static final String AMOUNT_OPTIONS = "/amountOptions?billerId=";
+	public static final String PLAN_CATEGORIES = "/planCategories?billerId=";
+	public static final String INITIATING_CHANNEL = "/initiatingChannel";
+
+	public static final String BILLER_VALIDATE_URL = "/couapp/bills/validate";
+	public static final String BILL_ID_URL = "/couapp/bills/validate/byId?billId=";
 
 }

src/main/resources/application.properties

@@ -2,16 +2,16 @@ spring.application.name=bbps
 
 
 # Server port
-server.port=9090
+server.port=8080
 
 # JPA & Hibernate
 spring.jpa.hibernate.ddl-auto=update
 spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
 
 # DataSource
-spring.datasource.url=jdbc:postgresql://localhost:5432/BBPS
+spring.datasource.url=jdbc:postgresql://localhost:5432/TestingDB
 spring.datasource.username=postgres
-spring.datasource.password=thakur@123
+spring.datasource.password=UAT@DB_2025
 spring.datasource.driver-class-name=org.postgresql.Driver
 spring.datasource.type=com.zaxxer.hikari.HikariDataSource