improved logs

src/main/java/com/billpaymentservice/bbps/audit/Auditable.java

@@ -1,16 +1,14 @@
 package com.billpaymentservice.bbps.audit;
 
 import java.io.Serializable;
-import java.util.Date; 
+import java.util.Date;
 
 import org.springframework.data.annotation.CreatedBy;
 import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.LastModifiedBy;
 import org.springframework.data.annotation.LastModifiedDate;
- 
 
 import jakarta.persistence.Column;
-
 import jakarta.persistence.MappedSuperclass;
 import jakarta.persistence.Temporal;
 import jakarta.persistence.TemporalType;

src/main/java/com/billpaymentservice/bbps/config/RestClientConfig.java

@@ -1,15 +1,16 @@
 package com.billpaymentservice.bbps.config;
 
+import java.security.cert.X509Certificate;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
 import org.springframework.web.client.RestClient;
 
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.TrustManager;
-import javax.net.ssl.X509TrustManager;
-import java.security.cert.X509Certificate;
-
 @Configuration
 public class RestClientConfig {
 

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

@@ -3,7 +3,10 @@ package com.billpaymentservice.bbps.controller;
 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.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;

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

@@ -10,7 +10,6 @@ import org.springframework.web.bind.annotation.RestController;
 
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillPaymentRequest;
-import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
 import com.billpaymentservice.bbps.dto.request.TransactionStatusRequest;
 import com.billpaymentservice.bbps.service.PaymentService;
 

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

@@ -1,8 +1,8 @@
 package com.billpaymentservice.bbps.dto;
-import jakarta.persistence.*;
+import java.util.List;
+
 import lombok.Getter;
 import lombok.Setter;
-import java.util.List;
 
 @Getter
 @Setter

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

@@ -1,7 +1,9 @@
 package com.billpaymentservice.bbps.dto;
 
 import java.util.List;
+
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Size;
 import lombok.Getter;

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

@@ -1,8 +1,9 @@
 package com.billpaymentservice.bbps.dto;
 
+import java.util.List;
+
 import lombok.Getter;
 import lombok.Setter;
-import java.util.List;
 
 @Getter
 @Setter

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

@@ -1,11 +1,11 @@
 package com.billpaymentservice.bbps.dto;
+import java.util.List;
+
 import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
 
-import java.util.List;
-
 @Getter
 @Setter
 public class CustomerParamDTO {

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

@@ -1,10 +1,10 @@
 package com.billpaymentservice.bbps.dto;
+import java.util.List;
+
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 
-import java.util.List;
-
 @Getter
 @Setter
 @ToString

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

@@ -2,7 +2,6 @@ package com.billpaymentservice.bbps.dto;
 
 import lombok.Getter;
 import lombok.Setter;
-import lombok.ToString;
 
 @Getter
 @Setter

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

@@ -1,8 +1,9 @@
 package com.billpaymentservice.bbps.dto;
 
+import java.util.List;
+
 import lombok.Getter;
 import lombok.Setter;
-import java.util.List;
 
 @Getter
 @Setter

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

@@ -1,6 +1,5 @@
 package com.billpaymentservice.bbps.dto;
 
-import com.fasterxml.jackson.annotation.JsonProperty;
 import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;

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

@@ -2,7 +2,9 @@ package com.billpaymentservice.bbps.dto;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 
-import jakarta.validation.constraints.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.PositiveOrZero;
 import lombok.Getter;
 import lombok.Setter;
 

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

@@ -1,5 +1,6 @@
 package com.billpaymentservice.bbps.dto.request;
 import java.util.List;
+
 import lombok.Getter;
 import lombok.Setter;
 

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

@@ -1,7 +1,6 @@
 package com.billpaymentservice.bbps.dto.request;
 
 import lombok.Getter;
-
 import lombok.Setter;
 
 @Getter

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

@@ -1,6 +1,7 @@
 package com.billpaymentservice.bbps.dto.response;
 
 import com.billpaymentservice.bbps.dto.GeneralResp;
+
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;

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

@@ -2,7 +2,6 @@ package com.billpaymentservice.bbps.dto.response;
 
 import com.billpaymentservice.bbps.dto.BillerDTO;
 import com.billpaymentservice.bbps.dto.GeneralResp;
-import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
 

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

@@ -1,10 +1,9 @@
 package com.billpaymentservice.bbps.dto.response;
 
 import java.util.List;
-import com.billpaymentservice.bbps.dto.ContactMaster;
+
 import com.billpaymentservice.bbps.dto.CustomParamDTO;
 import com.billpaymentservice.bbps.dto.GeneralResp;
-import com.billpaymentservice.bbps.entites.CustomerParam;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
 import lombok.AllArgsConstructor;

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

@@ -1,8 +1,15 @@
 package com.billpaymentservice.bbps.entites;
 
 
-import jakarta.persistence.*;
-import jakarta.validation.constraints.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;

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

@@ -3,8 +3,6 @@ package com.billpaymentservice.bbps.entites;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.Id;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.OneToOne;
 import jakarta.persistence.Table;
 import lombok.AllArgsConstructor;
 import lombok.Getter;

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

@@ -1,7 +1,12 @@
 package com.billpaymentservice.bbps.entites;
 
 
-import jakarta.persistence.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 

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

@@ -1,10 +1,19 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
-import java.util.List;
-import com.fasterxml.jackson.annotation.JsonProperty;
 
 @Entity
 @Table(name = "amount_option")

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

@@ -1,10 +1,5 @@
 package com.billpaymentservice.bbps.entites;
 
-import java.time.LocalDateTime;
-
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import com.billpaymentservice.bbps.audit.Auditable;
 
 import jakarta.persistence.Column;

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

@@ -1,6 +1,11 @@
 package com.billpaymentservice.bbps.entites;
-import jakarta.persistence.*;
-import lombok.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
 @AllArgsConstructor

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

@@ -1,9 +1,6 @@
 package com.billpaymentservice.bbps.entites;
-import java.time.LocalDateTime;
 import java.util.List;
 
-import com.billpaymentservice.bbps.dto.BillerResponseBill;
-
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Entity;
 import jakarta.persistence.Id;

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

@@ -2,7 +2,14 @@ package com.billpaymentservice.bbps.entites;
 
 import java.time.LocalDateTime;
 import java.util.List;
-import jakarta.persistence.*;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 

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

@@ -1,14 +1,21 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
-import jakarta.validation.constraints.*;
-import lombok.Getter;
-import lombok.Setter;
-import lombok.ToString;
+import java.util.List;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 
-import java.util.List;
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
 
 @Getter
 @Setter

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

@@ -1,15 +1,17 @@
 package com.billpaymentservice.bbps.entites;
 
-import java.util.List;
-
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
-import jakarta.persistence.*;
-import jakarta.validation.constraints.*;
-import lombok.Getter;
-import lombok.Setter;
-import java.util.List;
 
 @Getter
 @Setter

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

@@ -1,7 +1,5 @@
 package com.billpaymentservice.bbps.entites;
 
-import java.time.LocalDate;
-
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.GeneratedValue;

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

@@ -1,11 +1,21 @@
 package com.billpaymentservice.bbps.entites;
 
 
-import jakarta.persistence.*;
+import java.util.List;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
 import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
-import java.util.List;
 
 @Getter
 @Setter

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

@@ -1,6 +1,11 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;

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

@@ -1,13 +1,24 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
-import jakarta.validation.constraints.*;
+import java.util.List;
+
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 
-import java.util.List;
-
 @Getter
 @Setter
 @Entity

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

@@ -1,7 +1,11 @@
 package com.billpaymentservice.bbps.entites;
 
 
-import jakarta.persistence.*;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 

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

@@ -1,12 +1,22 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
+import java.util.List;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 
-import java.util.List;
-
 @Getter
 @Setter
 @Entity

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

@@ -1,7 +1,9 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
-
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;

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

@@ -1,12 +1,24 @@
 package com.billpaymentservice.bbps.entites;
 
 
-import jakarta.persistence.*;
+import java.util.List;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 
-import java.util.List;
-
 @Getter
 @Setter
 @Entity

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

@@ -2,14 +2,20 @@ package com.billpaymentservice.bbps.entites;
 
 import java.util.List;
 
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
-import jakarta.persistence.*;
-import jakarta.validation.constraints.*;
-import lombok.Getter;
-import lombok.Setter;
-import java.util.List;
 
 @Getter
 @Setter

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

@@ -2,16 +2,20 @@ package com.billpaymentservice.bbps.entites;
 
 import java.util.List;
 
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
 
-
-import jakarta.persistence.*;
-import jakarta.validation.constraints.*;
-import lombok.Getter;
-import lombok.Setter;
-import java.util.List;
-
 @Getter
 @Setter
 @Entity

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

@@ -1,6 +1,13 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 

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

@@ -1,13 +1,18 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
-import jakarta.validation.constraints.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 
-import com.fasterxml.jackson.annotation.JsonProperty;
-
 @Getter
 @Setter
 @Entity

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

@@ -5,8 +5,6 @@ package com.billpaymentservice.bbps.entites;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.FetchType;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;

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

@@ -1,6 +1,14 @@
 package com.billpaymentservice.bbps.entites;
 
-import jakarta.persistence.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.Setter;
 

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

@@ -1,61 +1,57 @@
 package com.billpaymentservice.bbps.exception;
 
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.*;
+import org.springframework.validation.FieldError;
 import org.springframework.web.bind.MethodArgumentNotValidException;
-import org.springframework.web.bind.annotation.ControllerAdvice;
-import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.*;
 
 import com.billpaymentservice.bbps.dto.ResponseModel;
 
-import java.util.HashMap;
-import java.util.Map;
-
 @ControllerAdvice
 public class GlobalExceptionHandler {
 
-    // ✅ Handle CustomException
-    @ExceptionHandler(CustomException.class)
-    public ResponseEntity<ResponseModel<?>> handleCustomException(CustomException ex) {
-        return new ResponseEntity<>(ex.getResponseModel(), HttpStatus.BAD_REQUEST);
-    }
+    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
 
-    // ✅ Handle validation errors
     @ExceptionHandler(MethodArgumentNotValidException.class)
-    public ResponseEntity<ResponseModel<?>> handleValidationExceptions(MethodArgumentNotValidException ex) {
+    public ResponseEntity<ResponseModel<?>> handleValidation(MethodArgumentNotValidException ex) {
+        List<Map<String, String>> fieldErrors = ex.getBindingResult().getFieldErrors()
+            .stream()
+            .map(fe -> Map.of("field", fe.getField(), "message", fe.getDefaultMessage()))
+            .collect(Collectors.toList());
 
-        Map<String, String> errors = new HashMap<>();
-
-        ex.getBindingResult().getFieldErrors().forEach(error -> {
-            errors.put(error.getField(), error.getDefaultMessage());
-        });
-
-        ResponseModel<?> response = new ResponseModel<>(
-                "Validation Failed",
-                "FAILED",
-                HttpStatus.BAD_REQUEST.value(),
-                errors
+        logger.warn("Validation failed: {}", fieldErrors);
+        ResponseModel<List<Map<String, String>>> resp = new ResponseModel<>(
+            "Validation failed for request",
+            "FAILED",
+            HttpStatus.BAD_REQUEST.value(),
+            null
         );
+        // put validation errors into data or duplicate field in ResponseModel as required
+        resp.setData(fieldErrors);
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(resp);
+    }
 
-        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
+    @ExceptionHandler(AppException.class)
+    public ResponseEntity<ResponseModel<?>> handleAppException(AppException ex) {
+        logger.warn("AppException: status={}, message={}", ex.getStatus(), ex.getMessage());
+        ResponseModel<?> resp = new ResponseModel<>(ex.getMessage(), ex.getStatus(), ex.getStatusCode(), ex.getData());
+        return ResponseEntity.status(HttpStatus.valueOf(ex.getStatusCode())).body(resp);
     }
 
-    // ✅ NEW: Handle ALL other exceptions (Generic Handler)
     @ExceptionHandler(Exception.class)
-    public ResponseEntity<ResponseModel<?>> handleAllExceptions(Exception ex) {
-        
-        // ✅ Internal logging (tumhare system ko pata chale)
-        System.err.println("INTERNAL SERVER ERROR: " + ex.getMessage());
-        ex.printStackTrace(); // Stack trace for debugging
-        
-        // ✅ Client ko generic message
+    public ResponseEntity<ResponseModel<?>> handleAll(Exception ex) {
+        logger.error("Unhandled exception", ex);
         ResponseModel<?> response = new ResponseModel<>(
             "Service temporarily unavailable. Please try again later.",
             "FAILED",
             HttpStatus.INTERNAL_SERVER_ERROR.value(),
             null
         );
-
-        return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
     }
-}
+}

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

@@ -1,7 +1,6 @@
 package com.billpaymentservice.bbps.repository;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
-import org.springframework.web.servlet.function.ServerRequest.Headers;
 
 import com.billpaymentservice.bbps.entites.BharatConnectMaster;
 

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

@@ -1,14 +1,13 @@
 package com.billpaymentservice.bbps.repository;
 
 
+import java.util.Optional;
+
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 import com.billpaymentservice.bbps.entites.BillerDetails;
 
-import java.util.List;
-import java.util.Optional;
-
 @Repository
 public interface BillerDataRepository extends JpaRepository<BillerDetails, String> {
 	

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

@@ -7,11 +7,8 @@ import com.billpaymentservice.bbps.dto.request.CustomParamRequest;
 import com.billpaymentservice.bbps.dto.request.DispositionRequest;
 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.request.PlanRequest;
 
-import jakarta.servlet.http.HttpServletRequest;
-
 public interface MasterDataService {
 
 	public ResponseModel getBillerByBillerId(BillerDetailRequest billerDetailRequest);

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

@@ -2,7 +2,6 @@ package com.billpaymentservice.bbps.service;
 
 import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.request.BillPaymentRequest;
-import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
 import com.billpaymentservice.bbps.dto.request.TransactionStatusRequest;
 
 public interface PaymentService {

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

@@ -1,8 +1,9 @@
 package com.billpaymentservice.bbps.serviceImpl;
 
-import java.time.LocalDateTime;
 import java.util.Map;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
@@ -39,7 +40,6 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.extern.slf4j.Slf4j;
 
 @Service
-@Slf4j
 public class AgentServiceImpl implements AgentService {
 
 	@Value("${agent.data.url}")
@@ -51,7 +51,7 @@ public class AgentServiceImpl implements AgentService {
 	private final BharatConnectMasterRepository beneficiaryDetailsRepository;
 	private final BillMasterRepository billMasterRepository;
 	private final BillInitateRepository billIntiateRepository;
-
+	private static final Logger LOGGER = LoggerFactory.getLogger(AgentServiceImpl.class);
 	public AgentServiceImpl(RestClient restClient, HttpService httpService, Helper helper,
 			BharatConnectMasterRepository beneficiaryDetailsRepository,InboundTraceLogRepository inboundTraceLogRepository,
 			OutboundTraceLogRepository outboundTraceLogRepository, BillMasterRepository billMasterRepository,BillInitateRepository billIntiateRepository) {	
@@ -64,13 +64,13 @@ public class AgentServiceImpl implements AgentService {
 	}
 	
 	
-
 	@Override
 	public ResponseModel initiateBillFetch(FetchBillRequest fetchBillRequest) {
+	    LOGGER.info("Initiating bill fetch for request ID: {} and MID", fetchBillRequest.getReqId(), fetchBillRequest.getMid());
 	    String apiName = "InitiateBillFetch";
 	    String txnId = helper.generateTxnId(15);
 	    String requestId = fetchBillRequest.getReqId();
-	    String url = agentDtaUrl + BBPSConstant.BILL_FETCH_INTI;
+	    String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_INTI;
 
 	    helper.validateMerchant(fetchBillRequest.getMid());
 
@@ -87,71 +87,74 @@ public class AgentServiceImpl implements AgentService {
 
 	    // ✅ Create inbound & outbound logs
 	    InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnId, apiName, fetchBillRequest.getMid(), "POST", requestJson);
-	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, requestId, apiName, url, "POST", requestJson);
+	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, requestId, apiName, fullUrl, "POST", requestJson);
+	    LOGGER.debug("Outbound log created successfully for txnId: {} and reqId: {}", txnId, requestId);
 
 	    try {
-	        Map<String, String> responseMap = httpService.postRequest(url, requestJson, headers);
+	        LOGGER.info("Calling external API: {}", fullUrl);
+	        Map<String, String> responseMap = httpService.postRequest(fullUrl, requestJson, headers);
 	        String responseData = responseMap.get("data");
 
-	        log.info("📦 Bill Fetch API Response: {}", responseData);
 	        helper.updateOutboundLogResponse(outboundLog, responseData);
+	        LOGGER.debug("Response received from BBPS: {}", responseData);
 
 	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
 	        if (!dataMap.containsKey("genericResponse")) {
-	        	 helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
-	                throw new CustomException(
-	                    String.valueOf(dataMap.get("message")),
-	                    String.valueOf(dataMap.get("status")),
-	                    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
-	                    String.valueOf(dataMap.get("remarks"))
-	                );
+	            helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+	            LOGGER.warn("Invalid response received for txnId: {}", txnId);
+	            throw new CustomException(
+	                String.valueOf(dataMap.get("message")),
+	                String.valueOf(dataMap.get("status")),
+	                Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
+	                String.valueOf(dataMap.get("remarks"))
+	            );
 	        }
-            
+
 	        BillMaster billMaster = new BillMaster();
 	        billMaster.setBillId((String) dataMap.get("billId"));
 	        billMaster.setReqId(fetchBillRequest.getReqId());
 	        billMaster.setTxnId(txnId);
 	        billMasterRepository.save(billMaster);
+	        LOGGER.info("BillMaster saved for billId: {}", billMaster.getBillId());
+
 	        FetchBillResponse fetchBillResponse = objectMapper.convertValue(dataMap, FetchBillResponse.class);
 	        GeneralResp generalResponse = fetchBillResponse.getGenericResponse();
 	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResponse.getStatus());
-	        //save intitate bill here
+
 	        BillInitiate billInitiate = new BillInitiate();
 	        billInitiate.setBillId((String) dataMap.get("billId"));
 	        billInitiate.setReqId(fetchBillRequest.getReqId());
 	        billInitiate.setTxnId(txnId);
 	        billIntiateRepository.save(billInitiate);
-	        
-	        
+	        LOGGER.info("BillInitiate entry saved for billId: {}", billInitiate.getBillId());
+
 	        BillFetchByBillIdRequest billFetchByBillIdRequest = new BillFetchByBillIdRequest();
 	        billFetchByBillIdRequest.setBillId(fetchBillResponse.getBillId());
 	        billFetchByBillIdRequest.setMid(fetchBillRequest.getMid());
 	        billFetchByBillIdRequest.setReqId(requestId);
-	        
+	        LOGGER.info("Waiting for 2 seconds before fetching bill by ID...");
 	        try {
 	            Thread.sleep(2000);
 	        } catch (InterruptedException e) {
-	            Thread.currentThread().interrupt(); // restore interrupted flag
-	            log.warn("Thread interrupted during delay: {}", e.getMessage());
+	            Thread.currentThread().interrupt();
+	            LOGGER.warn("Thread interrupted during delay: {}", e.getMessage());
 	        }
-	        
+	        LOGGER.info("Calling internal method Fetching bill by ID: {}", billFetchByBillIdRequest.getBillId());
 	        return fetchBillById(billFetchByBillIdRequest, inboundLog);
 	    } catch (JsonProcessingException e) {
-	        log.error("❌ JSON Parsing Error: {}", e.getMessage());
+	        LOGGER.error("JSON Parsing Error: {}", e.getMessage(), e);
 	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 	        throw new CustomException("Invalid JSON received from API");
-	    } 
+	    }
 	}
 
-	
-	
-	
 	public ResponseModel fetchBillById(BillFetchByBillIdRequest billFetchByBillIdRequest, InboundTraceLog inboundLog) {
+	    LOGGER.info("Fetching bill by BILLID for request ID={} and MID={}", billFetchByBillIdRequest.getReqId(), billFetchByBillIdRequest.getMid());
 	    String apiName = "FetchBillById";
 	    String txnId = helper.generateTxnId(15);
 	    String reqId = billFetchByBillIdRequest.getReqId();
 	    String billId = billFetchByBillIdRequest.getBillId();
-	    String url = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID + "1ced7566-1add-4e01-9ed6-04cd67ac9684";
+	    String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID + "1ced7566-1add-4e01-9ed6-04cd67ac9684";
 
 	    helper.validateMerchant(billFetchByBillIdRequest.getMid());
 
@@ -163,239 +166,252 @@ public class AgentServiceImpl implements AgentService {
 	    headers.setContentType(MediaType.APPLICATION_JSON);
 
 	    ObjectMapper objectMapper = new ObjectMapper();
-	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, url, "GET", null);
+	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, reqId, apiName, fullUrl, "GET", null);
+	    LOGGER.debug("Outbound log created successfully for FetchBillById: {}", fullUrl);
 
-	  
-	        try {
-	            Map<String, String> responseMap = httpService.getRequest(url, headers);
-	            String responseData = responseMap.get("data");
-	            log.info("📦 Bill FetchById Response: {}", responseData);
+	    try {
+	        LOGGER.info("Calling external API: {}", fullUrl);
+	        Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
+	        String responseData = responseMap.get("data");
+	        LOGGER.info("Bill FetchById Response: {}", responseData);
 
-	           helper.updateOutboundLogResponse(outboundLog, responseData);
+	        helper.updateOutboundLogResponse(outboundLog, responseData);
 
-	            Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
+	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
 
-	            if (!dataMap.containsKey("genericResponse")) {
-	                helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
-	                throw new CustomException(
-	                    String.valueOf(dataMap.get("message")),
-	                    String.valueOf(dataMap.get("status")),
-	                    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
-	                    String.valueOf(dataMap.get("remarks"))
-	                );
-	            }
-
-	            BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
-	            GeneralResp generalResp = responseWrapper.getGenericResponse();
-
-	            String status = generalResp.getStatus();
-	            log.info("📡 Current Bill Status: {}", status);
-	            // ✅ Check for "INPROGRESS" or pending state
-	           
-	            
-	            // ✅ Final successful response
-	            helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
-	            helper.saveOrUpdateBillerData(responseWrapper,billFetchByBillIdRequest);
-	            
-	            return new ResponseModel(
-	                    generalResp.getMessage(),
-	                    generalResp.getStatus(),
-	                    Integer.parseInt(generalResp.getStatusCode()),
-	                    responseWrapper
+	        if (!dataMap.containsKey("genericResponse")) {
+	            helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+	            LOGGER.warn("Invalid response structure for txnId: {}", txnId);
+	            throw new CustomException(
+	                String.valueOf(dataMap.get("message")),
+	                String.valueOf(dataMap.get("status")),
+	                Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
+	                String.valueOf(dataMap.get("remarks"))
 	            );
-	        } catch (JsonProcessingException e) {
-	            log.error("Error parsing BillById JSON: {}", e.getMessage());
-	            helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
-	            throw new CustomException("Invalid JSON received from API");
-	        } 
+	        }
+
+	        BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
+	        GeneralResp generalResp = responseWrapper.getGenericResponse();
+
+	        String status = generalResp.getStatus();
+	        LOGGER.info("Current Bill Status: {}", status);
+
+	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+	        helper.saveOrUpdateBillerData(responseWrapper,billFetchByBillIdRequest);
+	        LOGGER.info("Bill data saved successfully for billId: {}", billId);
+
+	        return new ResponseModel(
+	                generalResp.getMessage(),
+	                generalResp.getStatus(),
+	                Integer.parseInt(generalResp.getStatusCode()),
+	                responseWrapper
+	        );
+	    } catch (JsonProcessingException e) {
+	        LOGGER.error("Error parsing BillById JSON: {}", e.getMessage(), e);
+	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+	        throw new CustomException("Invalid JSON received from API");
 	    }
+	}
 
 	@Override
 	public ResponseModel fetchBillById(BillFetchByBillIdRequest billFetchByBillIdRequest) {
-		    String apiName = "FetchBillById";
-		    String txnId = helper.generateTxnId(15);
-		    String reqId = billFetchByBillIdRequest.getReqId();
-		    String billId = billFetchByBillIdRequest.getBillId();
-		    String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID + "1ced7566-1add-4e01-9ed6-04cd67ac9684";
+	    String apiName = "FetchBillById";
+	    String txnId = helper.generateTxnId(15);
+	    String reqId = billFetchByBillIdRequest.getReqId();
+	    String billId = billFetchByBillIdRequest.getBillId();
+	    String fullUrl = agentDtaUrl + BBPSConstant.BILL_FETCH_BY_ID + "1ced7566-1add-4e01-9ed6-04cd67ac9684";
 
-		try {
-			helper.validateMerchant(billFetchByBillIdRequest.getMid());
-			BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
-			HttpHeaders headers = new HttpHeaders();
-			headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
-			headers.set("agentId", headersData.getAgentId());
-			headers.set("tenantId", headersData.getTenantId());
-			headers.setContentType(MediaType.APPLICATION_JSON);
-			Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
-			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("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);
-			
-	        helper.saveOrUpdateBillerData(responseWrapper,billFetchByBillIdRequest);
-			
-			return responseModel;
+	    LOGGER.info("Initiating {} API for billId={} and reqId={}", apiName, billId, reqId);
 
-		} 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 {
-
-	        helper.validateMerchant(fetchBillValidateRequest.getMid());
+	        helper.validateMerchant(billFetchByBillIdRequest.getMid());
+	        LOGGER.debug("Merchant validated successfully for MID={}", billFetchByBillIdRequest.getMid());
 
 	        BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
-
-	        if (headersData == null) {
-	            responseModel = new ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST, headersData);
-	            return responseModel;
-	        }
-
 	        HttpHeaders headers = new HttpHeaders();
 	        headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
 	        headers.set("agentId", headersData.getAgentId());
 	        headers.set("tenantId", headersData.getTenantId());
 	        headers.setContentType(MediaType.APPLICATION_JSON);
 
-	        ObjectMapper objectMapper = new ObjectMapper();
-	        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-	        String json = objectMapper.writeValueAsString(fetchBillValidateRequest);
-	        String url = agentDtaUrl + BBPSConstant.BILLER_VALIDATE_URL;
-
-	        Map<String, String> responseMap = httpService.postRequest(url, json, headers);
+	        LOGGER.info("Calling external BBPS API for FetchBillById, URL={}", fullUrl);
+	        Map<String, String> responseMap = httpService.getRequest(fullUrl, headers);
 	        String responseData = responseMap.get("data");
+	        LOGGER.info("Response received from BBPS for billId={} : {}", billId, responseData);
 
-	        log.info("📦 Bill Fetch API Response: {}", responseData);
+	        ObjectMapper objectMapper = new ObjectMapper();
+	        Map<String, Object> dataMap = objectMapper.readValue(responseData,
+	                new TypeReference<Map<String, Object>>() {});
 
-	        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");
+	            LOGGER.warn("Invalid response structure received for billId={} | Response={}", billId, responseData);
+	            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"))
+	            );
 	        }
 
-	        // ✅ 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
+	        BillDataResponse responseWrapper = objectMapper.convertValue(dataMap, BillDataResponse.class);
+	        GeneralResp generalResp = responseWrapper.getGenericResponse();
+	        ResponseModel responseModel = new ResponseModel(
+	                generalResp.getMessage(),
+	                generalResp.getStatus(),
+	                Integer.parseInt(generalResp.getStatusCode()),
+	                responseWrapper
 	        );
 
-	    } catch (CustomException ex) {
-	        log.warn("Merchant validation failed: {}", ex.getMessage());
-	        return ex.getResponseModel(); // Directly return ResponseModel from exception
-	    } catch (Exception e) {
-	        log.error("❌ Exception in initiateBillFetch(): {}", e.getMessage(), e);
-	        responseModel.setStatus("500");
-	        responseModel.setMessage("Exception occurred");
-	        responseModel.setData(e.getMessage());
-	    }
+	        helper.saveOrUpdateBillerData(responseWrapper, billFetchByBillIdRequest);
+	        LOGGER.info("Bill data saved successfully for billId={} | Status={}", billId, generalResp.getStatus());
 
-	    return responseModel;
+	        return responseModel;
+
+	    } catch (JsonProcessingException e) {
+	        LOGGER.error("Error parsing responseData JSON for billId={} : {}", billId, e.getMessage(), e);
+	        throw new CustomException("Invalid JSON received from API");
+	    }
 	}
 
+
+	@Override
+	public ResponseModel initiateBillValidate(FetchBillValidatestRequest fetchBillValidateRequest) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+
 	@Override
 	public ResponseModel initiateBillValidateByBillId(BillFetchByBillIdRequest billRequest) {
-
-	    ResponseModel responseModel = new ResponseModel();
-	    try {
-	        helper.validateMerchant(billRequest.getMid());
-
-	        BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
-
-	        if (headersData == null) {
-	            responseModel = new ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST, headersData);
-	            return responseModel;
-	        }
-
-	        HttpHeaders headers = new HttpHeaders();
-	        headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
-	        headers.set("agentId", headersData.getAgentId());
-	        headers.set("tenantId", headersData.getTenantId());
-	        headers.setContentType(MediaType.APPLICATION_JSON);
-
-	        ObjectMapper objectMapper = new ObjectMapper();
-	        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-	        String json = objectMapper.writeValueAsString(billRequest);
-	        String url = agentDtaUrl + BBPSConstant.BILL_ID_URL + billRequest.getBillId();
-
-	        log.info("Full URL: {}", url);
-	        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-
-	        // ✅ Call the API using httpService
-	        Map<String, String> responseMap = httpService.getRequest(url, headers);
-	        String responseData = responseMap.get("data");
-
-	        log.info("📦 Bill Fetch API Response: {}", responseData);
-
-	        if (responseData == null || responseData.isEmpty()) {
-	            throw new CustomException("Empty response from BBPS server");
-	        }
-
-	        // ✅ Convert JSON string → Map
-	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
-
-	        // ✅ Validate generalResp
-	        if (!dataMap.containsKey("genericResponse")) {
-	            throw new CustomException("Invalid response structure from BBPS");
-	        }
-
-	        // ✅ Convert to your custom DTO
-	        BillDataResponse fetchBillResponse = objectMapper.convertValue(dataMap, BillDataResponse.class);
-	        GeneralResp generalResponse = fetchBillResponse.getGenericResponse();
-
-	        // ✅ Build final ResponseModel
-	        responseModel = new ResponseModel(
-	                generalResponse.getRemarks(),
-	                generalResponse.getStatus(),
-	                Integer.parseInt(generalResponse.getStatusCode()),
-	                fetchBillResponse
-	        );
-
-	    } catch (CustomException ex) {
-	        log.warn("Merchant validation failed: {}", ex.getMessage());
-	        return ex.getResponseModel(); // Directly return ResponseModel from exception
-	    } catch (Exception e) {
-	        log.error("❌ Exception in initiateBillFetch(): {}", e.getMessage(), e);
-	        responseModel.setStatus("500");
-	        responseModel.setMessage("Exception occurred");
-	        responseModel.setData(e.getMessage());
-	    }
-
-	    return responseModel;
+		// TODO Auto-generated method stub
+		return null;
 	}
+
 	
 	
+
+	
+	/*
+	 * @Override public ResponseModel
+	 * initiateBillValidate(FetchBillValidatestRequest fetchBillValidateRequest) {
+	 * 
+	 * ResponseModel responseModel = new ResponseModel(); try {
+	 * 
+	 * helper.validateMerchant(fetchBillValidateRequest.getMid());
+	 * 
+	 * BharatConnectMaster headersData =
+	 * beneficiaryDetailsRepository.findByOrgId("ORG001");
+	 * 
+	 * if (headersData == null) { responseModel = new
+	 * ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST,
+	 * headersData); return responseModel; }
+	 * 
+	 * HttpHeaders headers = new HttpHeaders(); headers.set("x-digiledge-key",
+	 * headersData.getXDigiledgeKey()); headers.set("agentId",
+	 * headersData.getAgentId()); headers.set("tenantId",
+	 * headersData.getTenantId());
+	 * headers.setContentType(MediaType.APPLICATION_JSON);
+	 * 
+	 * ObjectMapper objectMapper = new ObjectMapper();
+	 * objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); String
+	 * json = objectMapper.writeValueAsString(fetchBillValidateRequest); String url
+	 * = agentDtaUrl + BBPSConstant.BILLER_VALIDATE_URL;
+	 * 
+	 * Map<String, String> responseMap = httpService.postRequest(url, json,
+	 * headers); String responseData = responseMap.get("data");
+	 * 
+	 * log.info("📦 Bill Fetch API Response: {}", responseData);
+	 * 
+	 * if (responseData == null || responseData.isEmpty()) { throw new
+	 * CustomException("Empty response from BBPS server"); }
+	 * 
+	 * // ✅ Convert JSON string → Map Map<String, Object> dataMap =
+	 * objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>()
+	 * {});
+	 * 
+	 * // ✅ Validate generalResp if (!dataMap.containsKey("genericResponse")) {
+	 * throw new CustomException("Invalid response structure from BBPS"); }
+	 * 
+	 * // ✅ Convert to your custom DTO FetchBillValidatestResponse fetchBillResponse
+	 * = objectMapper.convertValue(dataMap, FetchBillValidatestResponse.class);
+	 * GeneralResp generalResponse = fetchBillResponse.getGenericResponse();
+	 * 
+	 * // ✅ Build final ResponseModel responseModel = new ResponseModel(
+	 * generalResponse.getMessage(), generalResponse.getStatus(),
+	 * Integer.parseInt(generalResponse.getStatusCode()), fetchBillResponse );
+	 * 
+	 * } catch (CustomException ex) { log.warn("Merchant validation failed: {}",
+	 * ex.getMessage()); return ex.getResponseModel(); // Directly return
+	 * ResponseModel from exception } catch (Exception e) {
+	 * log.error("❌ Exception in initiateBillFetch(): {}", e.getMessage(), e);
+	 * responseModel.setStatus("500");
+	 * responseModel.setMessage("Exception occurred");
+	 * responseModel.setData(e.getMessage()); }
+	 * 
+	 * return responseModel; }
+	 * 
+	 * @Override public ResponseModel
+	 * initiateBillValidateByBillId(BillFetchByBillIdRequest billRequest) {
+	 * 
+	 * ResponseModel responseModel = new ResponseModel(); try {
+	 * helper.validateMerchant(billRequest.getMid());
+	 * 
+	 * BharatConnectMaster headersData =
+	 * beneficiaryDetailsRepository.findByOrgId("ORG001");
+	 * 
+	 * if (headersData == null) { responseModel = new
+	 * ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST,
+	 * headersData); return responseModel; }
+	 * 
+	 * HttpHeaders headers = new HttpHeaders(); headers.set("x-digiledge-key",
+	 * headersData.getXDigiledgeKey()); headers.set("agentId",
+	 * headersData.getAgentId()); headers.set("tenantId",
+	 * headersData.getTenantId());
+	 * headers.setContentType(MediaType.APPLICATION_JSON);
+	 * 
+	 * ObjectMapper objectMapper = new ObjectMapper();
+	 * objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); String
+	 * json = objectMapper.writeValueAsString(billRequest); String url = agentDtaUrl
+	 * + BBPSConstant.BILL_ID_URL + billRequest.getBillId();
+	 * 
+	 * log.info("Full URL: {}", url);
+	 * objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+	 * 
+	 * // ✅ Call the API using httpService Map<String, String> responseMap =
+	 * httpService.getRequest(url, headers); String responseData =
+	 * responseMap.get("data");
+	 * 
+	 * log.info("📦 Bill Fetch API Response: {}", responseData);
+	 * 
+	 * if (responseData == null || responseData.isEmpty()) { throw new
+	 * CustomException("Empty response from BBPS server"); }
+	 * 
+	 * // ✅ Convert JSON string → Map Map<String, Object> dataMap =
+	 * objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>()
+	 * {});
+	 * 
+	 * // ✅ Validate generalResp if (!dataMap.containsKey("genericResponse")) {
+	 * throw new CustomException("Invalid response structure from BBPS"); }
+	 * 
+	 * // ✅ Convert to your custom DTO BillDataResponse fetchBillResponse =
+	 * objectMapper.convertValue(dataMap, BillDataResponse.class); GeneralResp
+	 * generalResponse = fetchBillResponse.getGenericResponse();
+	 * 
+	 * // ✅ Build final ResponseModel responseModel = new ResponseModel(
+	 * generalResponse.getRemarks(), generalResponse.getStatus(),
+	 * Integer.parseInt(generalResponse.getStatusCode()), fetchBillResponse );
+	 * 
+	 * } catch (CustomException ex) { log.warn("Merchant validation failed: {}",
+	 * ex.getMessage()); return ex.getResponseModel(); // Directly return
+	 * ResponseModel from exception } catch (Exception e) {
+	 * log.error("❌ Exception in initiateBillFetch(): {}", e.getMessage(), e);
+	 * responseModel.setStatus("500");
+	 * responseModel.setMessage("Exception occurred");
+	 * responseModel.setData(e.getMessage()); }
+	 * 
+	 * return responseModel; }
+	 */
+	
 	
 	/*    POLLING METHOD
 	 * public ResponseModel fetchBillById(BillFetchByBillIdRequest

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

@@ -8,13 +8,11 @@ import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
-import org.springframework.http.client.JdkClientHttpRequestFactory;
 import org.springframework.stereotype.Service;
 import org.springframework.web.client.HttpClientErrorException;
 import org.springframework.web.client.HttpServerErrorException;
 import org.springframework.web.client.RestClient;
 
-import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 import lombok.AllArgsConstructor;

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

@@ -1,11 +1,10 @@
 // java
 package com.billpaymentservice.bbps.serviceImpl;
 
-import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.stream.Collectors;
+
 import org.modelmapper.ModelMapper;
 import org.modelmapper.convention.MatchingStrategies;
 import org.slf4j.Logger;
@@ -69,7 +68,6 @@ public class MasterDataServiceImpl implements MasterDataService {
 	private final DispositionRepository dispositionRepository;
 	private final Helper helper;
 	private final BillerDataRepository billerDataRespository;
-	private static final Logger log = LoggerFactory.getLogger(MasterDataServiceImpl.class);
 	private final HttpService httpService;
 	private final ObjectMapper objectMapper = new ObjectMapper();
 	private final InboundTraceLogRepository inboundTraceLogRepository;
@@ -97,40 +95,26 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel getMasterData(MasterRequest masterRequest) {
-		LOGGER.info("Request DTO: {}", masterRequest);
-
+		LOGGER.info("Fetching Master Data for ReqId={} and MID={}", masterRequest.getReqId(), masterRequest.getMid());
 		String txnID = helper.generateTxnId(15);
 		String apiName = "GetMasterData";
 		String requestId = masterRequest.getReqId();
 		String requestJson = helper.convertObjectToJson(masterRequest);
-		
-     
 		InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, masterRequest.getMid(), "POST",
 				requestJson);
-         
 		try {
 			// Merchant Validation
 			helper.validateMerchant(masterRequest.getMid());
-
-//			if (!"Valid".equalsIgnoreCase(validateMerchant)) {
-//				LOGGER.warn("Merchant validation failed: {}", validateMerchant);
-//				return new ResponseModel("Merchant validation failed", validateMerchant, BBPSConstant.BADREQUEST, null);
-//			}
-
 			// check Tender Id is present DB
 			BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
-			log.info("Response -: " + headersData);
 			if (headersData == null) {
-				helper.updateInboundLogFailure(inboundLog, "Tenant Id Is Null", "NOT_FOUND");
-				return new ResponseModel("Tenant Id Is Null", "Not Found", BBPSConstant.BADREQUEST, headersData);
+				LOGGER.warn("header data not found for the orgID");
+				throw new CustomException("Something went wrong", "FAILED", 500, "");
 			}
-
 			// get full url
 			String fullUrl = masterRegisterUrl + BBPSConstant.MASTER_CATEGORY_URL + headersData.getTenantId();
 			LOGGER.info("Calling external API: {}", fullUrl);
-
 			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
-
 			Map<String, String> responseMap = httpService.getRequest(fullUrl);
 			String responseData = responseMap.get("data");
 			LOGGER.info("Response Data: {}", responseData);
@@ -158,7 +142,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 			return responseModel;
 
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		} 
@@ -166,7 +150,8 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel getBillerByBillerId(BillerDetailRequest billerDetailRequest) {
-		LOGGER.info("Fetching biller data for billerId={}", billerDetailRequest.getBillerId());
+		LOGGER.info("Fetching Biller Detail By Biller Id for ReqId={} and MID={}", billerDetailRequest.getReqId(), billerDetailRequest.getMid());
+
 		helper.validateMerchant(billerDetailRequest.getMid());
 		String txnID = helper.generateTxnId(15);
 		String apiName = "GetBillerByBillerId";
@@ -178,10 +163,10 @@ public class MasterDataServiceImpl implements MasterDataService {
 				requestJson);
 
 		OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
-
+		LOGGER.info("Calling external API: {}", fullUrl);
 		Map<String, String> responseMap = httpService.getRequest(fullUrl);
 		String responseData = responseMap.get("data");
-		log.info("fetched data from api is :{}", responseData);
+		LOGGER.info("fetched data from api is :{}", responseData);
 		helper.updateOutboundLogResponse(outboundLog, responseData);
 		try {
 			Map<String, Object> dataMap = objectMapper.readValue(responseData,
@@ -205,7 +190,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
 			return responseModel;
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		}    
@@ -214,7 +199,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 	@Override
 	public ResponseModel getCustomerParamByBillerId(CustomParamRequest customerParamRequest) {
 		
-		LOGGER.info("Fetching CustomerParam for billerId={}", customerParamRequest.getBillerId());
+		LOGGER.info("Fetching Customer Param By Biller Id for ReqId={} and MID={}", customerParamRequest.getReqId(), customerParamRequest.getMid());
 
 		String txnID = helper.generateTxnId(15);
 		String apiName = "GetCustomerParamByBillerId";
@@ -229,10 +214,10 @@ public class MasterDataServiceImpl implements MasterDataService {
 			String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMPARAM_URL + billerId;
 
 			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
-
+			LOGGER.info("Calling external API: {}", fullUrl);
 			Map<String, String> responseMap = httpService.getRequest(fullUrl);
 			String responseData = responseMap.get("data");
-			log.info("data is :{}", responseData);
+			LOGGER.info("data is :{}", responseData);
 
 			helper.updateOutboundLogResponse(outboundLog, responseData);
 
@@ -249,8 +234,6 @@ public class MasterDataServiceImpl implements MasterDataService {
 			
 			CustomParamResp responseWrapper = objectMapper.convertValue(dataMap, CustomParamResp.class);
 			List<CustomParamDTO> customParams = responseWrapper.getCustomParamResp();
-			
-
 			   GeneralResp generalResp = responseWrapper.getGeneralResp();
 		        List<CustomParamDTO> customParam = responseWrapper.getCustomParamResp();
 		            ModelMapper mapper = new ModelMapper();
@@ -260,21 +243,16 @@ public class MasterDataServiceImpl implements MasterDataService {
 		            List<CustomParam> entities = customParams.stream()
 		                    .map(dto -> mapper.map(dto, CustomParam.class))
 		                    .collect(Collectors.toList());
-
-		            // Debug print
-		            entities.forEach(System.out::println);
-
 		            // Save all to DB
 		            customParamReposiotory.saveAll(entities);
 		       
-
 			ResponseModel responseModel = new ResponseModel(generalResp.getMessage(), generalResp.getStatus(),
 					Integer.parseInt(generalResp.getStatusCode()), responseWrapper);
 			helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
 
 			return responseModel;
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		}
@@ -288,7 +266,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel fetchMasterDataCategoryWise(MasterCategoryRequest masterRequest) {
-		LOGGER.info("Fetching Master Data Category-wise " + masterRequest);
+		LOGGER.info("Fetching Master Data Category-wise for ReqId={} and MID={}", masterRequest.getReqId(), masterRequest.getMid());
 		String txnID = helper.generateTxnId(15);
 		String apiName = "FetchMasterDataCategoryWise";
 		String requestId = masterRequest.getReqId();
@@ -332,7 +310,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 			return responseModel;
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		}
@@ -340,6 +318,8 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel getDispositionDetails(DispositionRequest dispositionDetailRequest) {
+		LOGGER.info("Fetching Disposition Details for ReqId={} and MID={}", dispositionDetailRequest.getReqId(), dispositionDetailRequest.getMid());
+		
 		String txnID = helper.generateTxnId(15);
 		String apiName = "GetDispositionDetails";
 		String requestId = dispositionDetailRequest.getReqId();
@@ -351,6 +331,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 		String fullUrl = masterRegisterUrl + BBPSConstant.DISPOSTION_URL;
 		OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
+		LOGGER.info("Calling external API: {}", fullUrl);
 		Map<String, String> responseMap = httpService.getRequest(fullUrl);
 		String responseData = responseMap.get("data");
 
@@ -393,7 +374,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 			return responseModel;
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		} 
@@ -401,8 +382,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel fetchCustomerParamGroup(BillerDetailRequest requestModel) {
-		LOGGER.info("Fetching Master Data Category-wise for MID={}", requestModel.getMid());
-
+       LOGGER.info("Fetching Customer Param Group for ReqId={} and MID={}", requestModel.getReqId(), requestModel.getMid());
 		String txnID = helper.generateTxnId(15);
 		String apiName = "FetchCustomerParamGroup";
 		String requestId = requestModel.getReqId();
@@ -414,7 +394,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 			String fullUrl = masterRegisterUrl + BBPSConstant.CUSTOMER_PARAM_GROUP + requestModel.getBillerId();
 			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
-
+			LOGGER.info("Calling external API: {}", fullUrl);
 			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
 			String responseData = apiResponse.get("data").toString();
 			helper.updateOutboundLogResponse(outboundLog, responseData);
@@ -443,7 +423,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 			return responseModel;
 
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		} 
@@ -452,8 +432,8 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel fetchAllMasterAmountOption(BillerDetailRequest requestModel) {
-		LOGGER.info("Fetching Master Data Amount List for MID={}", requestModel.getMid());
 
+		LOGGER.info("Fetching Master Data Amount List for ReqId={} and MID={}", requestModel.getReqId(), requestModel.getMid());
 		String txnID = helper.generateTxnId(15);
 		String apiName = "FetchAllMasterAmountOption";
 		String requestId = requestModel.getReqId();
@@ -465,9 +445,9 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 			String fullUrl = masterRegisterUrl + BBPSConstant.AMOUNT_OPTIONS + requestModel.getBillerId();
 			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
-
+			LOGGER.info("Calling external API: {}", fullUrl);
 			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
-			log.info("Response" + apiResponse);
+			LOGGER.info("Response" + apiResponse);
 			String responseData = apiResponse.get("data").toString();
 
 			helper.updateOutboundLogResponse(outboundLog, responseData);
@@ -495,7 +475,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 			return responseModel;
 
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		}
@@ -504,8 +484,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel fetchPlanCategorie(BillerDetailRequest requestModel) {
-		LOGGER.info("Fetching Master Data Amount List for MID={}", requestModel.getMid());
-
+  		LOGGER.info("Fetching Plan Categories for ReqId={} and MID={}", requestModel.getReqId(), requestModel.getMid());
 		String txnID = helper.generateTxnId(15);
 		String apiName = "FetchPlanCategorie";
 		String requestId = requestModel.getReqId();
@@ -517,9 +496,9 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 			String fullUrl = masterRegisterUrl + BBPSConstant.PLAN_CATEGORIES + requestModel.getBillerId();
 			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
-
+			LOGGER.info("Calling external API: {}", fullUrl);
 			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
-			log.info("Response" + apiResponse);
+			LOGGER.info("Response" + apiResponse);
 			String responseData = apiResponse.get("data").toString();
 
 			helper.updateOutboundLogResponse(outboundLog, responseData);
@@ -547,7 +526,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 			return responseModel;
 
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		} 
@@ -555,8 +534,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 
 	@Override
 	public ResponseModel fetchInitiatingChannel(BillerDetailRequest requestModel) {
-		LOGGER.info("Fetching Initiating Channel List for MID={}", requestModel.getMid());
-
+     		LOGGER.info("Fetching Initiating Channel for ReqId={} and MID={}", requestModel.getReqId(), requestModel.getMid());
 		String txnID = helper.generateTxnId(15);
 		String apiName = "FetchInitiatingChannel";
 		String requestId = requestModel.getReqId();
@@ -567,12 +545,12 @@ public class MasterDataServiceImpl implements MasterDataService {
 			helper.validateMerchant(requestModel.getMid());
 
 			String fullUrl = masterRegisterUrl + BBPSConstant.INITIATING_CHANNEL;
-			LOGGER.info("Calling Master API: {}", fullUrl);
+
 
 			OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, fullUrl, "GET", null);
-
+			LOGGER.info("Calling Master API: {}", fullUrl);
 			Map<String, String> apiResponse = httpService.getRequest(fullUrl);
-			log.info("Response" + apiResponse);
+			LOGGER.info("Response" + apiResponse);
 			String responseData = apiResponse.get("data").toString();
 
 			helper.updateOutboundLogResponse(outboundLog, responseData);
@@ -600,15 +578,15 @@ public class MasterDataServiceImpl implements MasterDataService {
 			return responseModel;
 
 		} catch (JsonProcessingException e) {
-			log.error("Error parsing responseData JSON: {}", e.getMessage());
+			LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 			helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 			throw new CustomException("Invalid JSON received from API");
 		} 
 	}
 
 	public ResponseModel fetchPlanByCategories(PlanRequest requestModel) {
-	    LOGGER.info("Fetching Initiating Fetch Plan Category By Biller Id for MID={}", requestModel.getMid());
 
+		LOGGER.info("Fetching Plan By Categories for ReqId={} and MID={}", requestModel.getReqId(), requestModel.getMid());
 	    String txnID = helper.generateTxnId(15);
 	    String apiName = "FetchPlanByCategories";
 	    String requestId = requestModel.getReqId();
@@ -636,7 +614,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 	    try {
 	        Map<String, String> apiResponse = httpService.getRequest(url);
 	        String responseData = apiResponse.get("data");
-	        log.info("Response Data: {}", responseData);
+	        LOGGER.info("Response Data: {}", responseData);
 
 	        // Update outbound log with response
 	        helper.updateOutboundLogResponse(outboundLog, responseData);
@@ -669,7 +647,7 @@ public class MasterDataServiceImpl implements MasterDataService {
 	        return responseModel;
 
 	    } catch (JsonProcessingException e) {
-	        log.error("Error parsing responseData JSON: {}", e.getMessage());
+	    	LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
 	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 	        throw new CustomException("Invalid JSON received from API");
 	    } 

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

@@ -1,6 +1,5 @@
 package com.billpaymentservice.bbps.serviceImpl;
 
-import java.time.LocalDateTime;
 import java.util.Map;
 
 import org.modelmapper.ModelMapper;
@@ -11,20 +10,14 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Service;
-
 import com.billpaymentservice.bbps.dto.GeneralResp;
 import com.billpaymentservice.bbps.dto.ResponseModel;
-import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
 import com.billpaymentservice.bbps.dto.request.BillPaymentRequest;
-import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
 import com.billpaymentservice.bbps.dto.request.TransactionStatusRequest;
-import com.billpaymentservice.bbps.dto.response.BillDataResponse;
 import com.billpaymentservice.bbps.dto.response.BillPaymentResponse;
-import com.billpaymentservice.bbps.dto.response.FetchBillResponse;
 import com.billpaymentservice.bbps.dto.response.TransactionStatusResponse;
 import com.billpaymentservice.bbps.entites.AgentFundTransfer;
 import com.billpaymentservice.bbps.entites.BharatConnectMaster;
-import com.billpaymentservice.bbps.entites.BillInitiate;
 import com.billpaymentservice.bbps.entites.BillPayment;
 import com.billpaymentservice.bbps.entites.InboundTraceLog;
 import com.billpaymentservice.bbps.entites.OutboundTraceLog;
@@ -52,6 +45,7 @@ public class PaymentServiceImpl implements PaymentService {
 
 	@Value("${payment.data.url}")
 	private String paymentUrl;
+
 	private final BharatConnectMasterRepository beneficiaryDetailsRepository;
 	private final HttpService httpService;
 	private final Helper helper;
@@ -59,12 +53,14 @@ public class PaymentServiceImpl implements PaymentService {
 	private final InboundTraceLogRepository inboundTraceLogRepository;
 	private final OutboundTraceLogRepository outboundTraceLogRepository;
 	private final PaymentIntiateRepository paymentIntiateRepository;
-    private final TransactionMasterRepository transactionMasterRepository;
-    private final  AgentFundTransferRepository agentFundTransferRepository;
+	private final TransactionMasterRepository transactionMasterRepository;
+	private final AgentFundTransferRepository agentFundTransferRepository;
+
+	private static final Logger LOGGER = LoggerFactory.getLogger(PaymentServiceImpl.class);
+
 	public PaymentServiceImpl(BharatConnectMasterRepository beneficiaryDetailsRepository, HttpService httpService,
 			Helper helper, PaymentRepository paymentRepository, InboundTraceLogRepository inboundTraceLogRepository,
-			OutboundTraceLogRepository outboundTraceLogRepository,
-			PaymentIntiateRepository paymentIntiateRepository,
+			OutboundTraceLogRepository outboundTraceLogRepository, PaymentIntiateRepository paymentIntiateRepository,
 			TransactionMasterRepository transactionMasterRepository,
 			AgentFundTransferRepository agentFundTransferRepository) {
 		this.beneficiaryDetailsRepository = beneficiaryDetailsRepository;
@@ -78,7 +74,6 @@ public class PaymentServiceImpl implements PaymentService {
 		this.agentFundTransferRepository = agentFundTransferRepository;
 	}
 
-	private static final Logger LOGGER = LoggerFactory.getLogger(MasterDataServiceImpl.class);
 	@Override
 	public ResponseModel initiatePayment(BillPaymentRequest billPaymentRequest) {
 	    String apiName = "InitiatePayment";
@@ -86,6 +81,8 @@ public class PaymentServiceImpl implements PaymentService {
 	    String requestId = billPaymentRequest.getReqId();
 	    String url = paymentUrl + BBPSConstant.PAYMENT_URL;
 
+	    LOGGER.info("Initiating payment for reqId={} and txnId={}", requestId, txnId);
+
 	    BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
 	    HttpHeaders headers = new HttpHeaders();
 	    headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
@@ -98,25 +95,27 @@ public class PaymentServiceImpl implements PaymentService {
 
 	    String requestJson = helper.convertObjectToJson(billPaymentRequest);
 
-	    // ✅ Create inbound & outbound logs
 	    InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnId, apiName, billPaymentRequest.getMid(), "POST", requestJson);
 	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, requestId, apiName, url, "POST", requestJson);
 
 	    try {
+	        LOGGER.info("Calling BBPS payment URL: {}", url);
 	        Map<String, String> responseMap = httpService.postRequest(url, requestJson, headers);
 	        String responseData = responseMap.get("data");
+	        LOGGER.info("Payment API Response: {}", responseData);
 
-	        LOGGER.info("📦 Payment API Response: {}", responseData);
 	        helper.updateOutboundLogResponse(outboundLog, responseData);
 
 	        if (responseData == null || responseData.isEmpty()) {
 	        	helper.updateInboundLogFailure(inboundLog, "Empty response from BBPS", "FAILED");
+	        	LOGGER.warn("Empty response received from BBPS for txnId={}", txnId);
 	            throw new CustomException("Empty response from BBPS server");
 	        }
 
 	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
 	        if (!dataMap.containsKey("genericResponse")) {
 	        	helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_STRUCTURE");
+	        	LOGGER.warn("Invalid response structure received for txnId={}", txnId);
 	            throw new CustomException("Invalid response structure from BBPS");
 	        }
 
@@ -127,43 +126,44 @@ public class PaymentServiceImpl implements PaymentService {
 	        mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
 	        BillPayment entity = mapper.map(billPaymentResponse, BillPayment.class);
 	        paymentRepository.save(entity);
+	        LOGGER.info("BillPayment entity saved successfully for txnId={}", txnId);
 
 	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResponse.getStatus());
 	        PaymentInitiate paymentInitiate = new PaymentInitiate();
 	        paymentInitiate.setTxnId(txnId);
 	        paymentInitiate.setReqId(requestId);
 	        paymentInitiate.setBankTxnId(billPaymentResponse.getTxnId());
-	        paymentInitiate.setStatus(billPaymentResponse.getStatus());      
+	        paymentInitiate.setStatus(billPaymentResponse.getStatus());
 	        paymentIntiateRepository.save(paymentInitiate);
-	        // ✅ Trigger transaction status check
+	        LOGGER.info("PaymentInitiate entry saved successfully for txnId={}", txnId);
+
 	        TransactionStatusRequest transactionStatusRequest = new TransactionStatusRequest();
-	        transactionStatusRequest.setTxnId(billPaymentResponse.getTxnId()); 
+	        transactionStatusRequest.setTxnId(billPaymentResponse.getTxnId());
 	        transactionStatusRequest.setReqId(requestId);
             
-	        
-	         try {
-	             Thread.sleep(2000); // Initial wait before first status check
-	         } catch (InterruptedException e) {
-	             Thread.currentThread().interrupt();
-	             LOGGER.error("Thread interrupted: {}", e.getMessage());
-	         }
-	       
-	        //calling the method to check transaction status
+	        try {
+	            Thread.sleep(2000);
+	        } catch (InterruptedException e) {
+	            Thread.currentThread().interrupt();
+	            LOGGER.warn("Thread interrupted during payment delay: {}", e.getMessage());
+	        }
+	        LOGGER.info("Checking transaction status for txnId={}", billPaymentResponse.getTxnId());
 	        return checkTrasactionStatus(transactionStatusRequest, inboundLog);
 
 	    } catch (JsonProcessingException e) {
-	        LOGGER.error("❌ JSON Parsing Error: {}", e.getMessage());
+	        LOGGER.error("JSON Parsing Error in initiatePayment: {}", e.getMessage(), e);
 	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
 	        throw new CustomException("Invalid JSON received from API");
 	    }
-
 	}
-	
-	public ResponseModel checkTrasactionStatus(TransactionStatusRequest transactionStatusRequest,InboundTraceLog inboundLog) {
+
+	public ResponseModel checkTrasactionStatus(TransactionStatusRequest transactionStatusRequest, InboundTraceLog inboundLog) {
 	    String apiName = "CheckTransactionStatus";
-	    String txnId = helper.generateTxnId(15); //our genrated txnId
+	    String txnId = helper.generateTxnId(15);
 	    String requestId = transactionStatusRequest.getReqId();
-	    String url = paymentUrl + BBPSConstant.CHECK_TRANSACTION_URL + transactionStatusRequest.getTxnId(); ;
+	    String url = paymentUrl + BBPSConstant.CHECK_TRANSACTION_URL + transactionStatusRequest.getTxnId();
+
+	    LOGGER.info("Checking transaction status (internal) for txnId={} and reqId={}", transactionStatusRequest.getTxnId(), requestId);
 
 	    BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
 	    HttpHeaders headers = new HttpHeaders();
@@ -171,68 +171,66 @@ public class PaymentServiceImpl implements PaymentService {
 	    headers.set("agentId", headersData.getAgentId());
 	    headers.set("tenantId", headersData.getTenantId());
 	    headers.setContentType(MediaType.APPLICATION_JSON);
-	    ObjectMapper objectMapper = new ObjectMapper();
 
+	    ObjectMapper objectMapper = new ObjectMapper();
 	    OutboundTraceLog outboundLog = helper.createOutboundLog(txnId, requestId, apiName, url, "GET", null);
 
-	        Map<String, String> responseMap = httpService.getRequest(url, headers);
-	        String responseData = responseMap.get("data");
-	        LOGGER.info("Transaction status response: {}", responseData);
+	    Map<String, String> responseMap = httpService.getRequest(url, headers);
+	    String responseData = responseMap.get("data");
+	    LOGGER.info("Transaction status response: {}", responseData);
 
-	        helper.updateOutboundLogResponse(outboundLog, responseData);
+	    helper.updateOutboundLogResponse(outboundLog, responseData);
 
-	        try {
-	            Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
-
-	            if (!dataMap.containsKey("generalResp")) {
-	            	helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
-	                throw new CustomException(
-	                    String.valueOf(dataMap.get("message")),
-	                    String.valueOf(dataMap.get("status")),
-	                    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
-	                    String.valueOf(dataMap.get("remarks"))
-	                );
-	            }
-
-	            TransactionStatusResponse responseWrapper = objectMapper.convertValue(dataMap, TransactionStatusResponse.class);
-	            GeneralResp generalResp = responseWrapper.getGeneralResp();
-	            
-	            System.out.println("Response Wrapper:"+responseWrapper);
-	            
-	            
-	            ModelMapper mapper = new ModelMapper();
-	            mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
-	            TransactionMaster transactionMaster = mapper.map(responseWrapper.getTransactionDAO(), TransactionMaster.class);
-	            transactionMaster.setTxnId(txnId);
-	            transactionMaster.setReqId(transactionStatusRequest.getReqId());
-	            EntityRelationshipUtil.linkTransactionMasterRelationships(transactionMaster);
-	            transactionMasterRepository.save(transactionMaster);
-	            
-	            AgentFundTransfer agentFundTransfer = mapper.map(responseWrapper.getAgentFundTransfer(), AgentFundTransfer.class);
-	            agentFundTransfer.setTxnId(txnId);
-	            agentFundTransfer.setReqId(transactionStatusRequest.getReqId());
-	            agentFundTransfer.setTransactionMasterId(transactionMaster.getBankTxnId());
-	            agentFundTransferRepository.save(agentFundTransfer);
-	            String status = generalResp.getStatus();
-	            LOGGER.info("Current transaction status: {}", status);
-
-	            ResponseModel responseModel = new ResponseModel(
-	                    generalResp.getMessage(),
-	                    generalResp.getStatus(),
-	                    Integer.parseInt(generalResp.getStatusCode()),
-	                    responseWrapper
+	    try {
+	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
+	        if (!dataMap.containsKey("generalResp")) {
+	        	helper.updateInboundLogFailure(inboundLog, responseData, "INVALID_RESPONSE");
+	        	LOGGER.warn("Invalid transaction status response for txnId={}", transactionStatusRequest.getTxnId());
+	            throw new CustomException(
+	                String.valueOf(dataMap.get("message")),
+	                String.valueOf(dataMap.get("status")),
+	                Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
+	                String.valueOf(dataMap.get("remarks"))
 	            );
+	        }
 
-	            helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
-	            return responseModel;
+	        TransactionStatusResponse responseWrapper = objectMapper.convertValue(dataMap, TransactionStatusResponse.class);
+	        GeneralResp generalResp = responseWrapper.getGeneralResp();
+	        LOGGER.info("Transaction status received: {}", generalResp.getStatus());
 
-	        } catch (JsonProcessingException e) {
-	            LOGGER.error("Error parsing transaction status JSON: {}", e.getMessage());
-	            helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
-	            throw new CustomException("Invalid JSON received from API");
-	        } 
+	        ModelMapper mapper = new ModelMapper();
+	        mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
+	        TransactionMaster transactionMaster = mapper.map(responseWrapper.getTransactionDAO(), TransactionMaster.class);
+	        transactionMaster.setTxnId(txnId);
+	        transactionMaster.setReqId(transactionStatusRequest.getReqId());
+	        EntityRelationshipUtil.linkTransactionMasterRelationships(transactionMaster);
+	        transactionMasterRepository.save(transactionMaster);
+	        LOGGER.info("TransactionMaster saved successfully for txnId={}", txnId);
+
+	        AgentFundTransfer agentFundTransfer = mapper.map(responseWrapper.getAgentFundTransfer(), AgentFundTransfer.class);
+	        agentFundTransfer.setTxnId(txnId);
+	        agentFundTransfer.setReqId(transactionStatusRequest.getReqId());
+	        agentFundTransfer.setTransactionMasterId(transactionMaster.getBankTxnId());
+	        agentFundTransferRepository.save(agentFundTransfer);
+	        LOGGER.info("AgentFundTransfer entry saved successfully for txnId={}", txnId);
+
+	        ResponseModel responseModel = new ResponseModel(
+	                generalResp.getMessage(),
+	                generalResp.getStatus(),
+	                Integer.parseInt(generalResp.getStatusCode()),
+	                responseWrapper
+	        );
+
+	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+	        return responseModel;
+
+	    } catch (JsonProcessingException e) {
+	        LOGGER.error("Error parsing transaction status JSON: {}", e.getMessage(), e);
+	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+	        throw new CustomException("Invalid JSON received from API");
 	    }
-	
+	}
+
 	@Override
 	public ResponseModel checkTrasactionStatus(TransactionStatusRequest transactionStatusRequest) {
 		helper.validateMerchant(transactionStatusRequest.getMid());
@@ -241,60 +239,61 @@ public class PaymentServiceImpl implements PaymentService {
 		String requestId = transactionStatusRequest.getReqId();
 		String requestJson = helper.convertObjectToJson(transactionStatusRequest);
 	    String url = paymentUrl + BBPSConstant.CHECK_TRANSACTION_URL + transactionStatusRequest.getTxnId();
+
+	    LOGGER.info("Checking transaction status (public) for txnId={} and reqId={}", transactionStatusRequest.getTxnId(), requestId);
+
 	    BharatConnectMaster headersData = beneficiaryDetailsRepository.findByOrgId("ORG001");
 	    HttpHeaders headers = new HttpHeaders();
 	    headers.set("x-digiledge-key", headersData.getXDigiledgeKey());
 	    headers.set("agentId", headersData.getAgentId());
 	    headers.set("tenantId", headersData.getTenantId());
 	    headers.setContentType(MediaType.APPLICATION_JSON);
-	    InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, transactionStatusRequest.getMid(), "POST",
-				requestJson);
-       	OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, url, "GET", null);
+
+	    InboundTraceLog inboundLog = helper.createInboundLog(requestId, txnID, apiName, transactionStatusRequest.getMid(), "POST", requestJson);
+        OutboundTraceLog outboundLog = helper.createOutboundLog(txnID, requestId, apiName, url, "GET", null);
 	    ObjectMapper objectMapper = new ObjectMapper();
 
-	        Map<String, String> responseMap = httpService.getRequest(url, headers);
-	        String responseData = responseMap.get("data");
-	        LOGGER.info("Transaction status response data: {}", responseData);
-	        helper.updateOutboundLogResponse(outboundLog, responseData);
+	    Map<String, String> responseMap = httpService.getRequest(url, headers);
+	    String responseData = responseMap.get("data");
+	    LOGGER.info("Transaction status response data: {}", responseData);
+	    helper.updateOutboundLogResponse(outboundLog, responseData);
 
-	        try {
-	            Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
-
-	            // If genericResponse key missing, throw exception
-	            if (!dataMap.containsKey("generalResp")) {
-	            	helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
-	                throw new CustomException(
-	                        String.valueOf(dataMap.get("message")),
-	                        String.valueOf(dataMap.get("status")),
-	                        Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
-	                        String.valueOf(dataMap.get("remarks"))
-	                );
-	            }
-	            
-
-	            // Convert into proper DTO
-	            TransactionStatusResponse responseWrapper = objectMapper.convertValue(dataMap, TransactionStatusResponse.class);
-	            
-	            GeneralResp generalResp = responseWrapper.getGeneralResp();
-
-	            String status = generalResp.getStatus();
-	            LOGGER.info("Current transaction status: {}", status);
-	            ResponseModel responseModel = new ResponseModel(
-	                    generalResp.getMessage(),
-	                    generalResp.getStatus(),
-	                    Integer.parseInt(generalResp.getStatusCode()),
-	                    responseWrapper
+	    try {
+	        Map<String, Object> dataMap = objectMapper.readValue(responseData, new TypeReference<Map<String, Object>>() {});
+	        if (!dataMap.containsKey("generalResp")) {
+	        	helper.updateInboundLogFailure(inboundLog, responseData, String.valueOf(dataMap.get("status")));
+	        	LOGGER.warn("Invalid transaction status response for txnId={} from BBPS", transactionStatusRequest.getTxnId());
+	            throw new CustomException(
+	                    String.valueOf(dataMap.get("message")),
+	                    String.valueOf(dataMap.get("status")),
+	                    Integer.parseInt(String.valueOf(dataMap.get("statusCode"))),
+	                    String.valueOf(dataMap.get("remarks"))
 	            );
-	            helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
-	            return responseModel;
-
-	        } catch (JsonProcessingException e) {
-	            LOGGER.error("Error parsing responseData JSON: {}", e.getMessage());
-	            helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
-	            throw new CustomException("Invalid JSON received from API");
 	        }
+
+	        TransactionStatusResponse responseWrapper = objectMapper.convertValue(dataMap, TransactionStatusResponse.class);
+	        GeneralResp generalResp = responseWrapper.getGeneralResp();
+
+	        String status = generalResp.getStatus();
+	        LOGGER.info("Current transaction status: {}", status);
+
+	        ResponseModel responseModel = new ResponseModel(
+	                generalResp.getMessage(),
+	                generalResp.getStatus(),
+	                Integer.parseInt(generalResp.getStatusCode()),
+	                responseWrapper
+	        );
+
+	        helper.updateInboundLogSuccess(inboundLog, responseData, generalResp.getStatus());
+	        return responseModel;
+
+	    } catch (JsonProcessingException e) {
+	        LOGGER.error("Error parsing responseData JSON: {}", e.getMessage(), e);
+	        helper.updateInboundLogFailure(inboundLog, e.getMessage(), "JSON_ERROR");
+	        throw new CustomException("Invalid JSON received from API");
 	    }
 	}
+}
 
 	/*  PollBack logic for the fetchTxnByTxnId API
 	 * @Override public ResponseModel fetchTxnByTxnId(BillFetchByBillIdRequest

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

@@ -1,6 +1,9 @@
 package com.billpaymentservice.bbps.util;
 
-import com.billpaymentservice.bbps.entites.*;
+import com.billpaymentservice.bbps.entites.BillerDetails;
+import com.billpaymentservice.bbps.entites.BillerResponseParams;
+import com.billpaymentservice.bbps.entites.InterchangeFee;
+import com.billpaymentservice.bbps.entites.TransactionMaster;
 
 public class EntityRelationshipUtil {
 

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

@@ -3,33 +3,21 @@ package com.billpaymentservice.bbps.util;
 import java.security.SecureRandom;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
 
-import org.modelmapper.ModelMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
 
 import com.billpaymentservice.bbps.dto.AdditionalInfoBillDTO;
-import com.billpaymentservice.bbps.dto.AdditionalInfoDTO;
 import com.billpaymentservice.bbps.dto.CustomerParamDAO;
-import com.billpaymentservice.bbps.dto.CustomerParamDTO;
 import com.billpaymentservice.bbps.dto.ResponseModel;
+import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
+import com.billpaymentservice.bbps.dto.response.BillDataResponse;
 import com.billpaymentservice.bbps.entites.AdditionalInfoBill;
 import com.billpaymentservice.bbps.entites.BBPSMastersData;
-import com.billpaymentservice.bbps.exception.CustomException;
-import com.billpaymentservice.bbps.repository.BBPSMasterDataRepo;
-import com.billpaymentservice.bbps.repository.BillMasterRepository;
-import com.billpaymentservice.bbps.repository.BillerDataRepository;
-import com.billpaymentservice.bbps.repository.InboundTraceLogRepository;
-import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
-import com.billpaymentservice.bbps.dto.request.BillerDetailRequest;
-import com.billpaymentservice.bbps.dto.request.MerchantRequestModel;
-import com.billpaymentservice.bbps.dto.response.BillDataResponse;
-import com.billpaymentservice.bbps.entites.BBPSMerchantValidation;
 import com.billpaymentservice.bbps.entites.BillMaster;
 import com.billpaymentservice.bbps.entites.BillerDetails;
 import com.billpaymentservice.bbps.entites.BillerResponse;
@@ -39,9 +27,11 @@ import com.billpaymentservice.bbps.entites.OutboundTraceLog;
 import com.billpaymentservice.bbps.entites.PaymentChannel;
 import com.billpaymentservice.bbps.entites.PaymentMode;
 import com.billpaymentservice.bbps.exception.CustomException;
-import com.billpaymentservice.bbps.repository.MerchantRepository;
+import com.billpaymentservice.bbps.repository.BBPSMasterDataRepo;
+import com.billpaymentservice.bbps.repository.BillMasterRepository;
+import com.billpaymentservice.bbps.repository.BillerDataRepository;
+import com.billpaymentservice.bbps.repository.InboundTraceLogRepository;
 import com.billpaymentservice.bbps.repository.OutboundTraceLogRepository;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 @Component