Merge branch 'develop' into feature1

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

@@ -1,7 +1,6 @@
 package com.billpaymentservice.bbps.controller;
 
-
-import lombok.extern.slf4j.Slf4j;
+import java.util.List;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -9,62 +8,87 @@ 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.*;
-import org.springframework.http.ResponseEntity;
+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.GeneralResp;
+import com.billpaymentservice.bbps.dto.MasterApiResponse;
 import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
+import com.billpaymentservice.bbps.dto.request.MerchantRequestModel;
 import com.billpaymentservice.bbps.dto.response.BillerDataResponse;
-import com.billpaymentservice.bbps.service.MasterDataService; 
+import com.billpaymentservice.bbps.dto.response.BillerResponse;
+import com.billpaymentservice.bbps.service.MasterDataService;
 
+import jakarta.servlet.http.HttpServletRequest;
+
+@RequestMapping("/masterData")
 @RestController
 public class MasterDataController {
 
-    private final MasterDataService masterDataService;
-    private static final Logger log = LoggerFactory.getLogger(MasterDataController.class);
-    public MasterDataController(MasterDataService masterDataService) {
-        this.masterDataService = masterDataService;
-    }
-    @PostMapping(value = "/getBillerDetails",
-            consumes = MediaType.APPLICATION_JSON_VALUE,
-            produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<BillerDataResponse> getBillerDetails(
-            @Validated @RequestBody BillerDetailRequest billerDetailRequest) {
+	private static final Logger log = LoggerFactory.getLogger(MasterDataController.class);
 
-        log.info("Received biller details request for billerId: {}", billerDetailRequest.getBillerId());
+	private final MasterDataService masterDataService;
 
-        BillerDataResponse response = masterDataService.getBillerByBillerId(billerDetailRequest);
-        
-        HttpStatus status;
-        String statusCode = response.getGeneralResp() != null ? response.getGeneralResp().getStatusCode() : "500";
+	public MasterDataController(MasterDataService masterDataService) {
+		this.masterDataService = masterDataService;
+	}
 
-        switch (statusCode) {
-            case "200":
-                status = HttpStatus.OK;
-                break;
-            case "404":
-                status = HttpStatus.NOT_FOUND;
-                break;
-            case "500":
-                status = HttpStatus.INTERNAL_SERVER_ERROR;
-                break;
-            default:
-                status = HttpStatus.BAD_REQUEST;
-                break;
-        }
+	@PostMapping(value = "/getBillerDetails", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<BillerDataResponse> getBillerDetails(
+			@Validated @RequestBody BillerDetailRequest billerDetailRequest) {
 
-        log.info("Returning response for billerId: {} with HTTP status: {}", billerDetailRequest.getBillerId(), status);
+		log.info("Received biller details request for billerId: {}", billerDetailRequest.getBillerId());
 
-        return new ResponseEntity<>(response, status);
+		BillerDataResponse response = masterDataService.getBillerByBillerId(billerDetailRequest);
 
-       
-        }
-    }
+		HttpStatus status;
+		String statusCode = response.getGeneralResp() != null ? response.getGeneralResp().getStatusCode() : "500";
 
-   
+		switch (statusCode) {
+		case "200":
+			status = HttpStatus.OK;
+			break;
+		case "404":
+			status = HttpStatus.NOT_FOUND;
+			break;
+		case "500":
+			status = HttpStatus.INTERNAL_SERVER_ERROR;
+			break;
+		default:
+			status = HttpStatus.BAD_REQUEST;
+			break;
+		}
 
+		log.info("Returning response for billerId: {} with HTTP status: {}", billerDetailRequest.getBillerId(), status);
 
+		return new ResponseEntity<>(response, status);
 
+	}
+
+	@PostMapping("/getBillerById")
+	public String getBillerById(@RequestBody BillerDetailRequest billerRequestRequest) {
+		masterDataService.getBillerByBillerId(billerRequestRequest);
+		return "Abc";
+	}
+
+	/** Get All Masters API Fetch All Category from BBPS URL **/
+	@GetMapping("/getAllMasters")
+	public ResponseEntity<List<MasterApiResponse>> fetchMasterData(
+			@Validated @RequestBody MerchantRequestModel requestModel, HttpServletRequest request) {
+		log.info("Fetching Master Data Registered URL");
+		return masterDataService.getMasterData(requestModel, request);
+	}
+
+	/** Get Master Category Wise API Fetch Category Wise from BBPS URL **/
+	@GetMapping("/getMasterCategoryWise")
+	public ResponseEntity<BillerResponse> getMasterDataCategoryWise(
+			@Validated @RequestBody MerchantRequestModel requestModel, HttpServletRequest request,
+			@RequestParam String category, @RequestParam(defaultValue = "0") int pageStart, @RequestParam int pageEnd) {
+
+		log.info("Request received: category=" + category + ", pageNumber=" + pageStart + ", pageSize=" + pageEnd);
+		return masterDataService.fetchMasterDataCategoryWise(requestModel, category, pageStart, pageEnd);
+	}
+}

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

@@ -0,0 +1,12 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class FaqDetailsResponse {
+
+	private String name;
+	private String value;
+}

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

@@ -0,0 +1,21 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class GeneralResponse {
+
+	private String statusCode;
+	private String status;
+	private String message;
+	private String remarks;
+
+}

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

@@ -0,0 +1,23 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.response.CategoryResponse;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString
+public class MasterApiResponse {
+
+	private GeneralResponse generalResp;
+	private List<CategoryResponse> categoryRespList;
+
+}

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

@@ -0,0 +1,25 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class MasterCategoryBillerResponse {
+
+	private String billerId;
+	private String billerName;
+	private String billerType;
+	private String billerCategory;
+	private String billerCoverage;
+	private String billerResponseType;
+	private String billerDescription;
+	private String planMDMRequirement;
+	private String adhocBiller;
+	private String paymentAmountExactness;
+
+}

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

@@ -0,0 +1,13 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class MerchantRequestModel {
+
+	private String mid;
+	private String secretKey;
+	private String txnId;
+}

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

@@ -0,0 +1,26 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.GeneralResponse;
+import com.billpaymentservice.bbps.dto.MasterCategoryBillerResponse;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class BillerResponse {
+
+	private int pageNo;
+	private int pageSize;
+	private long totalElements;
+	private int totalPages;
+	private GeneralResponse generalResp;
+	private List<MasterCategoryBillerResponse> billerResp;
+
+}

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

@@ -0,0 +1,28 @@
+package com.billpaymentservice.bbps.dto.response;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.FaqDetailsResponse;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CategoryResponse {
+
+	private String categoryId;
+	private String categoryName;
+	private String categoryIcon;
+	private String categoryDomain;
+	private String buttonName;
+	private String textArea;
+	private List<FaqDetailsResponse> faqDetailsList;
+
+}

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

@@ -0,0 +1,46 @@
+package com.billpaymentservice.bbps.entites;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+@Table(name = "bbps_merchant_validation")
+public class BBPSMerchantValidation {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@Column(length = 35)
+	private String mid;
+
+	private String merchantName;
+
+	@Column(length = 50)
+	private String encKey;
+
+	private boolean active = true;
+
+	@Column(length = 100)
+	private String registeredEmailId;
+
+	private Long registeredMobileNo;
+
+	private String merchantCallbackUrl;
+
+	private String txtId;
+
+	private boolean is_deleted;
+}

src/main/java/com/billpaymentservice/bbps/exception/AppException.java

@@ -0,0 +1,35 @@
+package com.billpaymentservice.bbps.exception;
+
+import org.springframework.http.HttpStatus;
+
+import lombok.Getter;
+
+@Getter
+public class AppException extends RuntimeException {
+
+	private final String status;
+	private final String message;
+	private final int statusCode;
+	private final Object data;
+
+	public AppException(String message, HttpStatus httpStatus) {
+		this(message, httpStatus, null);
+	}
+
+	public AppException(String message, HttpStatus httpStatus, Object data) {
+		super(message);
+		this.message = message;
+		this.status = httpStatus.name();
+		this.statusCode = httpStatus.value();
+		this.data = data;
+	}
+
+	public AppException(String message2, String codeMerchantInvalid) {
+
+		this.message = message2;
+		this.status = codeMerchantInvalid;
+		this.statusCode = 0;
+		this.data = new Object();
+
+	}
+}

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

@@ -0,0 +1,12 @@
+package com.billpaymentservice.bbps.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+
+import com.billpaymentservice.bbps.entites.BBPSMerchantValidation;
+
+public interface MerchantRepository extends JpaRepository<BBPSMerchantValidation, Long> {
+
+	@Query("from BBPSMerchantValidation where mid = ?1 and is_deleted = false")
+	public BBPSMerchantValidation findByMid(String mid);
+}

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

@@ -1,10 +1,24 @@
 package com.billpaymentservice.bbps.service;
 
+import java.util.List;
+
+import org.springframework.http.ResponseEntity;
+
+import com.billpaymentservice.bbps.dto.MasterApiResponse;
 import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
+import com.billpaymentservice.bbps.dto.request.MerchantRequestModel;
 import com.billpaymentservice.bbps.dto.response.BillerDataResponse;
+import com.billpaymentservice.bbps.dto.response.BillerResponse;
+
+import jakarta.servlet.http.HttpServletRequest;
 
 public interface MasterDataService {
 
 	public BillerDataResponse getBillerByBillerId(BillerDetailRequest billerDetailRequest);
-	
+
+	public ResponseEntity<List<MasterApiResponse>> getMasterData(MerchantRequestModel requestModel,
+			HttpServletRequest request);
+
+	public ResponseEntity<BillerResponse> fetchMasterDataCategoryWise(MerchantRequestModel requestModel, String category, int pageStart, int pageEnd);
+
 }

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

@@ -0,0 +1,61 @@
+package com.billpaymentservice.bbps.serviceImpl;
+
+import java.util.Collections;
+import java.util.HashMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.HttpServerErrorException;
+import org.springframework.web.client.RestTemplate;
+
+@Service
+public class HttpClientApi {
+
+	private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientApi.class);
+
+	public HashMap<String, Object> getRequestForPaymentStatus(String url) {
+		HashMap<String, Object> responseMap = new HashMap<>();
+
+		try {
+			RestTemplate restTemplate = new RestTemplate();
+
+			HttpHeaders headers = new HttpHeaders();
+			headers.setContentType(MediaType.APPLICATION_JSON);
+			headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
+
+			HttpEntity<Void> request = new HttpEntity<>(headers);
+
+			LOGGER.info("BBPS: Payment Status Request URL: {}", url);
+
+			ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, request, String.class);
+
+			String responseBody = response.getBody();
+			LOGGER.info("Pesapal: Payment Status Response Body: {}", responseBody);
+
+			// Set response values in map
+			responseMap.put("respCode", response.getStatusCode());
+			responseMap.put("data", responseBody);
+
+		} catch (HttpClientErrorException | HttpServerErrorException httpEx) {
+			LOGGER.error("BBPS: HTTP error during payment status check", httpEx);
+			responseMap.put("respCode", String.valueOf(httpEx.getStatusCode()));
+			responseMap.put("data", "Exception: " + httpEx.getResponseBodyAsString());
+
+		} catch (Exception e) {
+			LOGGER.error("BBPS: Unexpected error during payment status check", e);
+			responseMap.put("respCode", String.valueOf(HttpStatus.EXPECTATION_FAILED));
+			responseMap.put("error", "Exception During REST Call: " + e.getMessage());
+		}
+
+		return responseMap;
+	}
+
+}

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

@@ -1,74 +1,189 @@
 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.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 org.springframework.util.StringUtils;
 
-import com.billpaymentservice.bbps.dto.BillerDAO;
-import com.billpaymentservice.bbps.dto.GeneralResp;
+import com.billpaymentservice.bbps.dto.MasterApiResponse;
 import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
+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.entites.BBPSMerchantValidation;
+import com.billpaymentservice.bbps.exception.AppException;
 import com.billpaymentservice.bbps.exception.CustomException;
+import com.billpaymentservice.bbps.repository.MerchantRepository;
 import com.billpaymentservice.bbps.service.MasterDataService;
-import com.billpaymentservice.bbps.serviceImpl.HttpService;
+import com.billpaymentservice.bbps.util.BBPSConstant;
+import com.billpaymentservice.bbps.util.ResponseParser;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
-
+import jakarta.servlet.http.HttpServletRequest;
 
 @Service
 public class MasterDataServiceImpl implements MasterDataService {
 
-    private static final Logger log = LoggerFactory.getLogger(MasterDataServiceImpl.class);
-    private final HttpService httpService;
-    private final ObjectMapper objectMapper = new ObjectMapper();
-    @Value("${bbps.billerDataFetch.url}")
-    private String billerDataFetchUrl;
+	private static final Logger LOGGER = LoggerFactory.getLogger(MasterDataServiceImpl.class);
 
-    // Inject HttpService
-    public MasterDataServiceImpl(HttpService httpService) {
-        this.httpService = httpService;
-    }
-    @Override
-    public BillerDataResponse getBillerByBillerId(BillerDetailRequest billerDetailRequest) {
+	@Value("${master.data.url}")
+	private String masterRegisterUrl;
 
-       
-            String billerId = billerDetailRequest.getBillerId();
-            String url = billerDataFetchUrl + billerId;
+	@Autowired
+	private MerchantRepository merchantRegisterRepo;
 
-            Map<String, String> responseMap = httpService.getRequest(url);
-            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("generalResp")) {
-                    throw new CustomException(
-                    		 String.valueOf(dataMap.get("statusCode")),
-                    		    String.valueOf(dataMap.get("status")),
-                    		    String.valueOf(dataMap.get("message")),
-                    		    String.valueOf(dataMap.get("remarks")));
-                }
-               BillerDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillerDataResponse.class);
-                return responseWrapper;
+	@Autowired
+	private HttpClientApi httpClientApi;
 
-            } catch (JsonProcessingException e) {
-                log.error("Error parsing responseData JSON: {}", e.getMessage());
-                throw new CustomException("Invalid JSON received from API");
-            }
-           
-    
-        }
+	@Autowired
+	private ResponseParser responseParser;
+
+	private static final Logger log = LoggerFactory.getLogger(MasterDataServiceImpl.class);
+	private final HttpService httpService;
+	private final ObjectMapper objectMapper = new ObjectMapper();
+	@Value("${bbps.billerDataFetch.url}")
+	private String billerDataFetchUrl;
+
+	// Inject HttpService
+	public MasterDataServiceImpl(HttpService httpService) {
+		this.httpService = httpService;
+	}
+
+	@Override
+	public BillerDataResponse getBillerByBillerId(BillerDetailRequest billerDetailRequest) {
+
+		String billerId = billerDetailRequest.getBillerId();
+		String url = billerDataFetchUrl + billerId;
+
+		Map<String, String> responseMap = httpService.getRequest(url);
+		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("generalResp")) {
+				throw new CustomException(String.valueOf(dataMap.get("statusCode")),
+						String.valueOf(dataMap.get("status")), String.valueOf(dataMap.get("message")),
+						String.valueOf(dataMap.get("remarks")));
+			}
+			BillerDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillerDataResponse.class);
+			return responseWrapper;
+
+		} catch (JsonProcessingException e) {
+			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			throw new CustomException("Invalid JSON received from API");
+		}
+
+	}
+
+	@Override
+	public ResponseEntity<List<MasterApiResponse>> getMasterData(MerchantRequestModel requestModel,
+			HttpServletRequest request) {
+		LOGGER.info("Request DTO" + request);
+
+		BBPSMerchantValidation merchantValidation = merchantRegisterRepo.findByMid(requestModel.getMid());
+		List<MasterApiResponse> responseModel = new ArrayList<>();
+		// 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);
+				String fullUrl = masterRegisterUrl + BBPSConstant.MASTER_CATEGORY_URL;
+				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();
+					MasterApiResponse generalResponse = responseParser.parseResponse(jsonData);
+
+					LOGGER.info("kkk" + generalResponse.toString());
+					// 5️⃣ Prepare API response model
+
+					responseModel.add(generalResponse);
+
+				} 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 {
+			LOGGER.info("Merchant Not Valid for mid - " + requestModel.getMid());
+			throw new AppException("Merchant Not Valid", BBPSConstant.CODE_MERCHANT_INVALID);
+		}
+		return ResponseEntity.ok(responseModel);
+
+	}
+
+	@Override
+	public ResponseEntity<BillerResponse> 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 {
+			LOGGER.info("Merchant Not Valid for mid - " + requestModel.getMid());
+			throw new AppException("Merchant Not Valid", BBPSConstant.CODE_MERCHANT_INVALID);
+		}
+		return ResponseEntity.ok(responseModel);
+
+	}
 }
-    
-    
-

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

@@ -2,4 +2,28 @@ package com.billpaymentservice.bbps.util;
 
 public class BBPSConstant {
 
+	public static final Long SENT_TO_PROCESSOR_CODE = 198L;
+	public static final Long SUCCESS_CODE = 200L;
+	public static final Long FAILED_CODE = 99L;
+	public static final Long SCHEDULER_CODE = 222L;
+	public static final Long PENDING_CODE = 211L;
+	public static final Long FRAUD_CODE = 1001L;
+
+	public static final String SUCCESS_STATUS = "success";
+	public static final String FAILED_STATUS = "failed";
+	public static final String PENDING_STATUS = "pending";
+	public static final String SENT_TO_PROCESSOR_STATUS = "txn sent to processor";
+
+	public static final String SUCCESS_REMARK = "200-Transaction process successfully";
+	public static final String FAILED_REMARK = "99-Transaction failed";
+	public static final String FRAUD_REMARK = "1001-Transaction failed due to a fraud attempt";
+
+	public static final String CODE_MERCHANT_INACTIVE = "B002";
+	public static final String CODE_MERCHANT_INVALID = "B003";
+
+	public static final String ENCRYPTION_FAILED = "Error in encrypting order request";
+
+	public static final String BILLER_URL = "/billers";
+	public static final String MASTER_CATEGORY_URL = "/categories-master?tenantId=FE41";
+
 }

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

@@ -0,0 +1,134 @@
+package com.billpaymentservice.bbps.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import com.billpaymentservice.bbps.dto.FaqDetailsResponse;
+import com.billpaymentservice.bbps.dto.GeneralResponse;
+import com.billpaymentservice.bbps.dto.MasterApiResponse;
+import com.billpaymentservice.bbps.dto.MasterCategoryBillerResponse;
+import com.billpaymentservice.bbps.dto.response.BillerResponse;
+import com.billpaymentservice.bbps.dto.response.CategoryResponse;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@Component
+public class ResponseParser {
+
+	private static final Logger LOGGER = LoggerFactory.getLogger(ResponseParser.class);
+
+	private final ObjectMapper mapper = new ObjectMapper();
+
+	public MasterApiResponse parseResponse(String jsonResponse) {
+		MasterApiResponse finalResponse = new MasterApiResponse();
+		ObjectMapper mapper = new ObjectMapper();
+
+		try {
+			JsonNode root = mapper.readTree(jsonResponse);
+
+			// ✅ Parse generalResp correctly
+			JsonNode generalRespNode = root.path("generalResp");
+			GeneralResponse generalResp = new GeneralResponse();
+			generalResp.setStatusCode(generalRespNode.path("statusCode").asText());
+			generalResp.setStatus(generalRespNode.path("status").asText());
+			generalResp.setMessage(generalRespNode.path("message").asText());
+			generalResp.setRemarks(generalRespNode.path("remarks").asText());
+			finalResponse.setGeneralResp(generalResp);
+
+			// ✅ Parse categoryRespList
+			List<CategoryResponse> categoryList = new ArrayList<>();
+			JsonNode categoryArray = root.path("categoryRespList");
+
+			if (categoryArray.isArray()) {
+				for (JsonNode node : categoryArray) {
+					CategoryResponse data = new CategoryResponse();
+					data.setCategoryId(node.path("categoryId").asText());
+					data.setCategoryName(node.path("categoryName").asText());
+					data.setCategoryIcon(node.path("categoryIcon").asText());
+					data.setCategoryDomain(node.path("categoryDomain").asText(""));
+					data.setButtonName(node.path("buttonName").asText(""));
+					data.setTextArea(node.path("textArea").asText(""));
+
+					// Parse faqDetailsList
+					List<FaqDetailsResponse> faqList = new ArrayList<>();
+					JsonNode faqArray = node.path("faqDetailsList");
+					if (faqArray.isArray()) {
+						for (JsonNode faqNode : faqArray) {
+							FaqDetailsResponse faq = new FaqDetailsResponse();
+							faq.setName(faqNode.path("name").asText());
+							faq.setValue(faqNode.path("value").asText());
+							faqList.add(faq);
+						}
+					}
+					data.setFaqDetailsList(faqList);
+					categoryList.add(data);
+				}
+			}
+
+			finalResponse.setCategoryRespList(categoryList);
+
+		} catch (Exception e) {
+			throw new RuntimeException("Failed to parse BBPS master API response", e);
+		}
+
+		return finalResponse;
+	}
+
+	public BillerResponse billerResponse(String jsonResponse) {
+		BillerResponse billerResponse = new BillerResponse();
+
+		try {
+			JsonNode root = mapper.readTree(jsonResponse);
+
+			// ✅ Pagination info
+			billerResponse.setPageNo(root.path("pageNo").asInt());
+			billerResponse.setPageSize(root.path("pageSize").asInt());
+			billerResponse.setTotalElements(root.path("totalElements").asLong());
+			billerResponse.setTotalPages(root.path("totalPages").asInt());
+
+			// ✅ General Response Info
+			JsonNode generalNode = root.path("generalResp");
+			GeneralResponse generalResp = new GeneralResponse();
+			generalResp.setStatusCode(generalNode.path("statusCode").asText());
+			generalResp.setStatus(generalNode.path("status").asText());
+			generalResp.setMessage(generalNode.path("message").asText());
+			generalResp.setRemarks(generalNode.path("remarks").asText());
+			billerResponse.setGeneralResp(generalResp);
+
+			// ✅ Parse biller list
+			List<MasterCategoryBillerResponse> billerList = new ArrayList<>();
+			JsonNode billerArray = root.path("billerResp");
+
+			if (billerArray.isArray()) {
+				for (JsonNode billerNode : billerArray) {
+					MasterCategoryBillerResponse biller = new MasterCategoryBillerResponse();
+					biller.setBillerId(billerNode.path("billerId").asText());
+					biller.setBillerName(billerNode.path("billerName").asText());
+					biller.setBillerType(billerNode.path("billerType").asText());
+					biller.setBillerCategory(billerNode.path("billerCategory").asText());
+					biller.setBillerCoverage(billerNode.path("billerCoverage").asText());
+					biller.setBillerResponseType(billerNode.path("billerResponseType").asText());
+					biller.setBillerDescription(billerNode.path("billerDescription").asText());
+					biller.setPlanMDMRequirement(billerNode.path("planMDMRequirement").asText());
+					biller.setAdhocBiller(billerNode.path("adhocBiller").asText());
+					biller.setPaymentAmountExactness(billerNode.path("paymentAmountExactness").asText());
+					billerList.add(biller);
+				}
+			}
+
+			billerResponse.setBillerResp(billerList);
+
+			LOGGER.info("✅ Successfully parsed BillerResponse with {} billers", billerList.size());
+
+		} catch (Exception e) {
+			LOGGER.error("❌ Error parsing BillerResponse: {}", e.getMessage(), e);
+			throw new RuntimeException("Failed to parse BBPS Biller API response", e);
+		}
+
+		return billerResponse;
+	}
+}

src/main/resources/application.properties

@@ -1,5 +1,9 @@
 spring.application.name=bbps
 
+
+# Server port
+server.port=9090
+
 # JPA & Hibernate
 spring.jpa.hibernate.ddl-auto=update
 spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
@@ -7,7 +11,7 @@ spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
 # DataSource
 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
 
@@ -19,19 +23,15 @@ spring.datasource.hikari.idle-timeout=2000000
 spring.datasource.hikari.max-lifetime=110000
 spring.datasource.hikari.auto-commit=true
 
-# Server port
-server.port=8086
-
 # Logging levels
 logging.level.io.github.resilience4j.retry=DEBUG
 
-# Certificate
-certificate.path=D:/Switch Document/rbl_lincpay/rbl_lincpay.pfx
-certificate.password=lincpay
-
 # BBPS URLs
 bbps.billerDataFetch.url=https://bbps-staging.digiledge.in/agent/cou-master/masters/billersById?billerId=
 
+# BBPS URLs
+master.data.url = https://bbps-staging.digiledge.in/agent/cou-master/masters
+
 # Resilience4j Retry
 resilience4j.retry.instances.callbackService.max-attempts=1
 resilience4j.retry.instances.callbackService.wait-duration=2s