update code

Reviewed-on: https://git.zeptic.in/himanshu/bbps/pulls/23

pom.xml

@@ -2,55 +2,42 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+
 	<modelVersion>4.0.0</modelVersion>
+
 	<parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>3.2.5</version>
-		<relativePath /> <!-- lookup parent from repository -->
+		<version>3.2.7</version> <!-- ✅ LTS and stable -->
+		<relativePath />
 	</parent>
+
 	<groupId>com.billpaymentservice.bbps</groupId>
 	<artifactId>bbps</artifactId>
 	<version>0.0.1-SNAPSHOT</version>
 	<packaging>war</packaging>
 	<name>bbps</name>
 	<description>This is the bbps switch project</description>
-	<url />
-	<licenses>
-		<license />
-	</licenses>
-	<developers>
-		<developer />
-	</developers>
-	<scm>
-		<connection />
-		<developerConnection />
-		<tag />
-		<url />
-	</scm>
+
 	<properties>
 		<java.version>17</java.version>
 	</properties>
-	<dependencies>
-		<dependency>
-			<groupId>io.github.resilience4j</groupId>
-			<artifactId>resilience4j-spring-boot3</artifactId>
-			<version>2.2.0</version> <!-- Latest stable version -->
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-aop</artifactId>
-		</dependency>
 
+	<dependencies>
+		<!-- Core Spring Boot Starters -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-data-jpa</artifactId>
+			<artifactId>spring-boot-starter</artifactId>
+		</dependency>
+		<!-- Validation -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-validation</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
 			<exclusions>
-				<!-- ❌ Exclude old HttpClient 4.x -->
 				<exclusion>
 					<groupId>org.apache.httpcomponents</groupId>
 					<artifactId>httpclient</artifactId>
@@ -58,53 +45,56 @@
 			</exclusions>
 		</dependency>
 
-		<dependency>
-			<groupId>com.fasterxml.jackson.dataformat</groupId>
-			<artifactId>jackson-dataformat-xml</artifactId>
-			<version>2.13.3</version>
-		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-devtools</artifactId>
-			<scope>runtime</scope>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>org.postgresql</groupId>
-			<artifactId>postgresql</artifactId>
-			<scope>runtime</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.projectlombok</groupId>
-			<artifactId>lombok</artifactId>
-			<version>1.18.30</version> <!-- Use latest stable -->
-			<scope>provided</scope>
+			<artifactId>spring-boot-starter-data-jpa</artifactId>
 		</dependency>
 
 		<dependency>
-			<groupId>com.nimbusds</groupId>
-			<artifactId>nimbus-jose-jwt</artifactId>
-			<version>9.37</version> <!-- Use latest stable version -->
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-aop</artifactId>
 		</dependency>
+
+		<!-- Tomcat (provided for WAR) -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-tomcat</artifactId>
 			<scope>provided</scope>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter</artifactId>
+			<artifactId>spring-boot-starter-security</artifactId>
 		</dependency>
+
+		<!-- Database Driver -->
 		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-test</artifactId>
-			<scope>test</scope>
+			<groupId>org.postgresql</groupId>
+			<artifactId>postgresql</artifactId>
+			<scope>runtime</scope>
 		</dependency>
+
+		<!-- Resilience4j -->
 		<dependency>
-			<groupId>org.springdoc</groupId>
-			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
-			<version>2.5.0</version>
+			<groupId>io.github.resilience4j</groupId>
+			<artifactId>resilience4j-spring-boot3</artifactId>
+			<version>2.2.0</version>
 		</dependency>
+
+		<!-- JSON + XML -->
+		<dependency>
+			<groupId>com.fasterxml.jackson.dataformat</groupId>
+			<artifactId>jackson-dataformat-xml</artifactId>
+		</dependency>
+
+		<!-- JWT -->
+		<dependency>
+			<groupId>com.nimbusds</groupId>
+			<artifactId>nimbus-jose-jwt</artifactId>
+			<version>9.37</version>
+		</dependency>
+
+		<!-- HttpClient 5 -->
 		<dependency>
 			<groupId>org.apache.httpcomponents.client5</groupId>
 			<artifactId>httpclient5</artifactId>
@@ -115,32 +105,75 @@
 			<artifactId>httpcore5</artifactId>
 			<version>5.2.5</version>
 		</dependency>
-
 		<dependency>
 			<groupId>org.apache.httpcomponents.core5</groupId>
 			<artifactId>httpcore5-h2</artifactId>
 			<version>5.2.5</version>
 		</dependency>
 
-
-		<!-- (Optional) ✅ Fluent API for HttpClient5 (useful if you ever need
-		direct HttpClient) -->
+		<!-- ModelMapper -->
 		<dependency>
-			<groupId>org.apache.httpcomponents.client5</groupId>
-			<artifactId>httpclient5-fluent</artifactId>
-			<version>5.3.1</version>
+			<groupId>org.modelmapper</groupId>
+			<artifactId>modelmapper</artifactId>
+			<version>3.2.0</version>
+		</dependency>
+
+		<!-- Lombok -->
+		<dependency>
+			<groupId>org.projectlombok</groupId>
+			<artifactId>lombok</artifactId>
+			<version>1.18.30</version>
+			<scope>provided</scope>
+		</dependency>
+
+		<!-- DevTools -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-devtools</artifactId>
+			<scope>runtime</scope>
+			<optional>true</optional>
+		</dependency>
+
+		<!-- Swagger / OpenAPI -->
+		<dependency>
+			<groupId>org.springdoc</groupId>
+			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+			<version>2.2.0</version>
+		</dependency>
+
+		<!-- JWT Runtime Implementations -->
+		<dependency>
+			<groupId>io.jsonwebtoken</groupId>
+			<artifactId>jjwt-api</artifactId>
+			<version>0.11.5</version>
+		</dependency>
+		<dependency>
+			<groupId>io.jsonwebtoken</groupId>
+			<artifactId>jjwt-impl</artifactId>
+			<version>0.11.5</version>
 			<scope>runtime</scope>
 		</dependency>
 		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-configuration-processor</artifactId>
-			<optional>true</optional>
+			<groupId>io.jsonwebtoken</groupId>
+			<artifactId>jjwt-jackson</artifactId>
+			<version>0.11.5</version>
+			<scope>runtime</scope>
 		</dependency>
+
+		<!-- Test -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+
+		<!-- Configuration Processor -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-configuration-processor</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 	</dependencies>
 
 	<build>
@@ -153,7 +186,7 @@
 						<path>
 							<groupId>org.projectlombok</groupId>
 							<artifactId>lombok</artifactId>
-							<version>1.18.42</version> <!-- ✅ Required -->
+							<version>1.18.30</version>
 						</path>
 					</annotationProcessorPaths>
 				</configuration>
@@ -162,16 +195,11 @@
 			<plugin>
 				<groupId>org.springframework.boot</groupId>
 				<artifactId>spring-boot-maven-plugin</artifactId>
-				<configuration>
-					<excludes>
-						<exclude>
-							<groupId>org.projectlombok</groupId>
-							<artifactId>lombok</artifactId>
-						</exclude>
-					</excludes>
-				</configuration>
 			</plugin>
+
+
 		</plugins>
+		<finalName>BBPS</finalName>
 	</build>
 
 </project>

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

@@ -8,9 +8,7 @@ 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/CORSConfig.java

@@ -0,0 +1,18 @@
+package com.billpaymentservice.bbps.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class CORSConfig implements WebMvcConfigurer {
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowedOrigins("*") // Or specific origin like "http://localhost:4200"
+                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
+                .allowedHeaders("*")
+                .allowCredentials(false); // Set to true if you're sending cookies
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.billpaymentservice.bbps.config;
+
+import java.util.ArrayList;
+import java.util.Optional;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+import com.billpaymentservice.bbps.entites.UserEntity;
+import com.billpaymentservice.bbps.entites.UsersDetails;
+import com.billpaymentservice.bbps.repository.UserRepository;
+import com.billpaymentservice.bbps.repository.UsersDetailsRepository;
+
+@Service
+public class CustomUserDetailsService implements UserDetailsService {
+
+	@Autowired
+	private UserRepository userRepository;
+
+	@Override
+	public UserDetails loadUserByUsername(String userMobNo) throws UsernameNotFoundException {
+
+		Optional<UserEntity> adminOptional = userRepository.findByMobile(userMobNo);
+
+		if (adminOptional.isPresent()) {
+			UserEntity user = adminOptional.get();
+			return new User(user.getMobile(), user.getName(), new ArrayList<>());
+		} else {
+			throw new UsernameNotFoundException("User not found with MobNo: " + userMobNo);
+		}
+	}
+
+}

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

@@ -0,0 +1,22 @@
+package com.billpaymentservice.bbps.config;
+
+import java.io.IOException;
+
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.AuthenticationEntryPoint;
+import org.springframework.stereotype.Component;
+
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+@Component
+public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
+
+	@Override
+	public void commence(HttpServletRequest request, HttpServletResponse response,
+			AuthenticationException authException) throws IOException, ServletException {
+		response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Access denied");
+
+	}
+}

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

@@ -0,0 +1,73 @@
+package com.billpaymentservice.bbps.config;
+
+import java.io.IOException;
+
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+import io.jsonwebtoken.ExpiredJwtException;
+import io.jsonwebtoken.MalformedJwtException;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+@Component
+public class JwtFilter extends OncePerRequestFilter {
+
+	private final JwtUtil jwtUtil;
+
+	private final CustomUserDetailsService userDetailsService;
+
+	public JwtFilter(JwtUtil jwtUtil, CustomUserDetailsService userDetailsService) {
+		this.jwtUtil = jwtUtil;
+		this.userDetailsService = userDetailsService;
+	}
+
+	@Override
+	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
+			throws ServletException, IOException {
+
+		final String authorizationHeader = request.getHeader("Authentication");
+
+		String mobileNo  = null;
+		String jwt = null;
+
+		if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
+			jwt = authorizationHeader.substring(7);
+			try {
+				mobileNo  = jwtUtil.extractUsername(jwt);
+			} catch (IllegalArgumentException e) {
+				System.out.println("unable to get jwt tokken");
+			} catch (ExpiredJwtException e) {
+				System.out.println("Jwt Exception jwt tokken");
+			} catch (MalformedJwtException e) {
+				System.out.println("invelid jwt token");
+			}
+		}
+
+		if (mobileNo  != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+
+			UserDetails userDetails = this.userDetailsService.loadUserByUsername(mobileNo);
+
+			if (jwtUtil.validateToken(jwt, userDetails)) {
+
+				UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
+						userDetails, null, userDetails.getAuthorities());
+				authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
+				SecurityContextHolder.getContext().setAuthentication(authentication);
+
+			} else {
+				System.out.println("JWT Filter: Token validation failed for user - " + mobileNo);
+
+			}
+		}
+
+		filterChain.doFilter(request, response);
+
+	}
+
+}

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

@@ -0,0 +1,130 @@
+package com.billpaymentservice.bbps.config;
+
+import java.security.Key;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.Base64;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Service;
+
+import com.billpaymentservice.bbps.util.BBPSConstant;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.security.Keys;
+
+@Service
+public class JwtUtil {
+
+	@Value("${jwt.secret}")
+	private String secret;
+
+	private final Map<String, Date> tokenBlacklist = new HashMap<>();
+
+	private Key getSigningKey() {
+		byte[] keyBytes = Decoders.BASE64.decode(secret);
+		return Keys.hmacShaKeyFor(keyBytes);
+	}
+
+	public String generateToken(String username, String mid) {
+		Map<String, Object> claims = new HashMap<>();
+		claims.put("mid", mid);
+		claims.put("expiryTime", new Date(System.currentTimeMillis() + BBPSConstant.JWT_EXPIRATION_MS).toString());
+		return createToken(claims, username.toUpperCase());
+	}
+
+	public String doGenerateRefreshToken(Map<String, Object> claims, String subject) {
+		return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
+				.setExpiration(new Date(System.currentTimeMillis() + BBPSConstant.REFRESH_EXPIRATION_MS))
+				.signWith(getSigningKey(), SignatureAlgorithm.HS512).compact();
+	}
+
+	public String extractUsername(String token) {
+		return extractClaim(token, Claims::getSubject);
+	}
+
+	public Date extractExpiration(String token) {
+		return extractClaim(token, Claims::getExpiration);
+	}
+
+	public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
+		final Claims claims = extractAllClaims(token);
+		return claimsResolver.apply(claims);
+	}
+
+	private Claims extractAllClaims(String token) {
+		return Jwts.parserBuilder().setSigningKey(getSigningKey()).build().parseClaimsJws(token).getBody();
+	}
+
+	private Boolean isTokenExpired(String token) {
+		return extractExpiration(token).before(new Date());
+	}
+
+	private String createToken(Map<String, Object> claims, String subject) {
+		return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
+				.setExpiration(new Date(System.currentTimeMillis() + BBPSConstant.JWT_TEMPERARY_EXPIRATION_MS))
+				.signWith(getSigningKey(), SignatureAlgorithm.HS512).compact();
+	}
+
+	private String createToken1(Map<String, Object> claims, String subject) {
+		return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
+				.setExpiration(new Date(System.currentTimeMillis() + BBPSConstant.JWT_EXPIRATION_MS))
+				.signWith(getSigningKey(), SignatureAlgorithm.HS512).compact();
+	}
+
+//	public Boolean validateToken(String token, UserDetails userDetails) {
+//		final String username = extractUsername(token);
+//		return true;
+//	}
+
+	public Boolean validateToken(String token, UserDetails userDetails) {
+		final String mobileNo = extractUsername(token);
+//		System.out.println("Extracted mobileNo  from token: " + mobileNo );
+//		System.out.println("Username from UserDetails: " + userDetails.getUsername());
+		return (mobileNo.equals(userDetails.getUsername()) && !isTokenExpired(token));
+	}
+
+	public void invalidateToken(String token) {
+		tokenBlacklist.put(token, new Date());
+	}
+
+	public boolean isTokenBlacklisted(String token) {
+		Date invalidationTime = tokenBlacklist.get(token);
+		return invalidationTime != null && invalidationTime.before(new Date());
+	}
+
+	public String generateToken(String mobileNo) {
+		Map<String, Object> claims = new HashMap<>();
+		claims.put("mobileNo", mobileNo);
+		return createToken1(claims, mobileNo);
+	}
+
+	public String generateTemperaryToken(String mobileNo) {
+		Map<String, Object> claims = new HashMap<>();
+		long currentTime = System.currentTimeMillis();
+		SimpleDateFormat sdf = new SimpleDateFormat("hh:mm a dd/MM/yyyy");
+		String formattedDate = sdf.format(new Date(currentTime));
+		claims.put("mobileNo", mobileNo);
+		claims.put("timestamp", formattedDate);
+		return createToken(claims, mobileNo);
+	}
+
+	public Claims parseToken(String token) {
+		byte[] decodedKey = Base64.getDecoder().decode(secret);
+		Key key = Keys.hmacShaKeyFor(decodedKey); // Generate the key
+
+		return Jwts.parserBuilder() // Use parserBuilder() instead of parser() as it's more modern
+				.setSigningKey(key) // Use the Key object
+				.build() // Build the JwtParser
+				.parseClaimsJws(token) // Parse the JWT
+				.getBody(); // Return claims
+	}
+
+}

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

@@ -0,0 +1,39 @@
+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;
+
+@Configuration
+public class RestClientConfig {
+
+    @Bean
+    public RestClient restClient() throws Exception {
+        // ✅ Create trust all SSL context
+        SSLContext sslContext = SSLContext.getInstance("TLS");
+        TrustManager[] trustAllCerts = new TrustManager[]{
+            new X509TrustManager() {
+                public X509Certificate[] getAcceptedIssuers() {
+                    return new X509Certificate[0];
+                }
+                public void checkClientTrusted(X509Certificate[] certs, String authType) {
+                }
+                public void checkServerTrusted(X509Certificate[] certs, String authType) {
+                }
+            }
+        };
+        sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
+
+        // ✅ Create RestClient with custom SSL context
+        return RestClient.builder()
+                .requestFactory(new HttpComponentsClientHttpRequestFactory())
+                .build();
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.billpaymentservice.bbps.config;
+
+import java.util.Arrays;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+	private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
+
+	private final JwtFilter jwtFilter;
+
+	public SecurityConfig(JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint, JwtFilter jwtFilter) {
+		this.jwtAuthenticationEntryPoint = jwtAuthenticationEntryPoint;
+		this.jwtFilter = jwtFilter;
+	}
+
+	@Bean
+	public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+
+		http.csrf(csrf -> csrf.disable()).cors(cors -> cors.configurationSource(corsConfigurationSource()))
+				.authorizeHttpRequests(auth -> auth
+						.requestMatchers("/auth/**", 
+								         "/v3/api-docs/**", 
+								         "/swagger-ui/**", 
+								         "/swagger-ui.html",
+								         "/swagger-resources/**", 
+								         "/webjars/**", 
+								         "/error")
+						.permitAll().requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
+						.anyRequest().authenticated())
+				.exceptionHandling(ex -> ex.authenticationEntryPoint(jwtAuthenticationEntryPoint))
+				.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS));
+
+		http.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
+
+		return http.build();
+	}
+
+	@Bean
+	public CorsConfigurationSource corsConfigurationSource() {
+		CorsConfiguration config = new CorsConfiguration();
+		config.setAllowedOrigins(Arrays.asList("*")); // Or use specific origin like "http://localhost:4200"
+		config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
+		config.setAllowedHeaders(Arrays.asList("*"));
+		config.setAllowCredentials(false); // true only if you're sending cookies
+
+		// Use UrlBasedCorsConfigurationSource as it implements CorsConfigurationSource
+		UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+		source.registerCorsConfiguration("/**", config); // Apply CORS to all paths
+		return source; // Return as CorsConfigurationSource
+	}
+}

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

@@ -0,0 +1,106 @@
+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.CrossOrigin;
+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.GeneralResp;
+import com.billpaymentservice.bbps.dto.ResponseModel;
+import com.billpaymentservice.bbps.dto.request.BillFetchByBillIdRequest;
+import com.billpaymentservice.bbps.dto.request.BillFetchByClientIdRequest;
+import com.billpaymentservice.bbps.dto.request.BillValidateByClientIdRequest;
+import com.billpaymentservice.bbps.dto.request.FetchBillRequest;
+import com.billpaymentservice.bbps.dto.request.FetchBillValidatestRequest;
+import com.billpaymentservice.bbps.dto.response.BillDataResponse;
+import com.billpaymentservice.bbps.dto.response.FetchBillValidateResponse;
+import com.billpaymentservice.bbps.service.AgentService;
+
+@RestController
+@RequestMapping("/agent")
+@CrossOrigin(origins = "*")
+public class AgentController {
+
+	private final AgentService agentService;
+
+	public AgentController(AgentService agentService) {
+		this.agentService = agentService;
+	}
+
+	/**
+	 * Fetches bill details from external BBPS service
+	 */
+	@PostMapping(value = "/requestBillFetch", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> requestBillFetch(@Validated @RequestBody FetchBillRequest fetchBillRequest) {
+
+		ResponseModel response = agentService.initiateBillFetch(fetchBillRequest);
+		return ResponseEntity.ok(response);
+	}
+
+	/**
+	 * Fetches bill details from external BBPS service
+	 */
+	@PostMapping(value = "/fetchBillById", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchBillById(
+			@Validated @RequestBody BillFetchByBillIdRequest billFetchByBillIdRequest) {
+
+		ResponseModel response = agentService.fetchBillById(billFetchByBillIdRequest);
+		return ResponseEntity.ok(response);
+	}
+
+	/**
+	 * Fetches bill details validate from external BBPS service
+	 */
+	@PostMapping(value = "/requestBillValidate", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> requestBillValidate(
+			@Validated @RequestBody FetchBillValidatestRequest fetchBillValidateRequest) {
+
+		ResponseModel response = agentService.initiateBillValidate(fetchBillValidateRequest);
+		return ResponseEntity.ok(response);
+	}
+
+	/**
+	 * Fetches bill details by bill Id from external BBPS service
+	 */
+	@PostMapping(value = "/requestBillValidateByBillId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> requestBillByBillId(
+			@Validated @RequestBody BillFetchByBillIdRequest billRequest) {
+
+		ResponseModel response = agentService.initiateBillValidateByBillId(billRequest);
+		return ResponseEntity.ok(response);
+	}
+	
+	@PostMapping(value = "/fetchBillByClientReqId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchBillByClientReqId(
+			@Validated @RequestBody  BillFetchByClientIdRequest billFetchByClientIdRequest) {
+
+		ResponseModel response = agentService.fetchBillByClientReqId(billFetchByClientIdRequest);
+		return ResponseEntity.ok(response);
+	}
+	
+	@PostMapping(value = "/fetchBillValidateByClientReqId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchBillValidateByClientReqId(
+			@Validated @RequestBody  BillValidateByClientIdRequest billValidateByClientIdRequest) {
+
+		ResponseModel response = agentService.fetchBillValidateByClientReqId(billValidateByClientIdRequest);
+		return ResponseEntity.ok(response);
+	}
+	
+	@PostMapping(value="/callback/billFetch", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<ResponseModel> handleBillFetchCallback(@RequestBody BillDataResponse billDataResponse) {
+		ResponseModel genralResp=agentService.processBillFetchCallback(billDataResponse);
+		// Return a response indicating successful receipt
+		return ResponseEntity.ok(genralResp);
+	}
+    
+	@PostMapping(value="/callback/billValidate", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<ResponseModel> handleBillValidateCallback(@RequestBody FetchBillValidateResponse fetchBillValidateResponse) {
+		ResponseModel genralResp=agentService.processBillValidateCallback(fetchBillValidateResponse);
+		// Return a response indicating successful receipt
+		return ResponseEntity.ok(genralResp);
+	}
+}

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

@@ -0,0 +1,60 @@
+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.CrossOrigin;
+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.auth.AuthResponse;
+import com.billpaymentservice.bbps.dto.response.AuthResponses;
+import com.billpaymentservice.bbps.dto.auth.LoginRequest;
+import com.billpaymentservice.bbps.dto.auth.OtpSendResponse;
+import com.billpaymentservice.bbps.dto.auth.RegisterRequest;
+import com.billpaymentservice.bbps.dto.auth.VerifyOtpRequest;
+import com.billpaymentservice.bbps.service.AuthService;
+
+import lombok.extern.slf4j.Slf4j;
+
+@RestController
+@RequestMapping("/auth")
+@CrossOrigin(origins = "*")
+@Slf4j
+public class AuthController {
+
+	private final AuthService authService;
+
+	public AuthController(AuthService authService) {
+		this.authService = authService;
+	}
+
+	@PostMapping(value = "/sendOtp", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> sendOtp(@Validated @RequestBody LoginRequest request) {
+		log.info("Received sendOtp request for mobile: {}", request.getMobile());
+		return ResponseEntity.ok(authService.sendOtp(request));
+	}
+
+	@PostMapping(value = "/verifyOtp", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> verifyOtp(@Validated @RequestBody VerifyOtpRequest request) {
+
+		return ResponseEntity.ok(authService.verifyOtp(request));
+	}
+
+	@PostMapping(value = "/register", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> register(@Validated @RequestBody RegisterRequest request) {
+
+		return ResponseEntity.ok(authService.registerUser(request));
+	}
+
+	@PostMapping("/loginWithoutDecryption")
+	public ResponseEntity<ResponseModel> login(@RequestBody LoginRequest loginRequest) {
+
+		return ResponseEntity.ok(authService.authenticateUser(loginRequest));
+
+	}
+
+}

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

@@ -0,0 +1,85 @@
+package com.billpaymentservice.bbps.controller;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.CrossOrigin;
+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.AllMasterOptionsRequest;
+import com.billpaymentservice.bbps.dto.request.ComplainStatusRequest;
+import com.billpaymentservice.bbps.dto.request.ComplaintRequestDTO;
+import com.billpaymentservice.bbps.dto.request.GetTicketLatestStausRequest;
+
+import com.billpaymentservice.bbps.dto.request.ViewAllComplaintsRequest;
+import com.billpaymentservice.bbps.dto.request.ViewAllComplaintsTicketsRequest;
+import com.billpaymentservice.bbps.service.ComplainService;
+
+@RestController
+@RequestMapping("/complaints")
+@Validated
+@CrossOrigin(origins = "*")
+public class ComplainController {
+
+	private static final Logger log = LoggerFactory.getLogger(ComplainController.class);
+
+	private final ComplainService complainService;
+
+	// ✅ Constructor name fixed and variable consistent
+	public ComplainController(ComplainService complainService) {
+		this.complainService = complainService;
+	}
+
+	@PostMapping(value = "/addComplainTicket", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> addComplain(@Validated @RequestBody ComplaintRequestDTO complainRequestDTO) {
+
+		ResponseModel response = complainService.addComplain(complainRequestDTO);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping(value = "/checkTicketStatus", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getComplaintStatus(
+			@Validated @RequestBody GetTicketLatestStausRequest request) {
+		log.info("Received complaint status request for complaintId: {}", request.getTicketId());
+		ResponseModel response = complainService.getComplaintStatus(request);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping(value = "/viewComplainsTicketHistory", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> viewComplaintHistory(@Validated @RequestBody ComplainStatusRequest request) {
+		log.info("Received complaint View Complaint History request for ticketId: {}", request.getTicketId());
+		ResponseModel response = complainService.viewComplaintHistory(request);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping("/viewTicketById")
+	public ResponseEntity<ResponseModel> viewComplaintById(@Validated @RequestBody ComplainStatusRequest request) {
+		log.info("Received complaint View Complaint By ID request for complaintId: {}", request.getTicketId());
+		ResponseModel response = complainService.viewComplaintById(request);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping("/allMasterOptions")
+	public ResponseEntity<ResponseModel> getAllStatuses(@Validated @RequestBody AllMasterOptionsRequest request) {
+		return ResponseEntity.ok(complainService.getAllActiveStatuses(request));
+	}
+
+	@PostMapping("/viewAllComplaints")
+	public ResponseEntity<ResponseModel> viewAllComplaints(@RequestBody ViewAllComplaintsTicketsRequest request) {
+		log.info("Received request complaint View All Complaints for Status Type={}", request.getStatusType());
+		ResponseModel response = complainService.ViewAllComplaints(request);
+		return ResponseEntity.ok(response);
+	}
+	
+	@PostMapping(value = "/viewAllComplaintsByUserId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> viewAllComplaintsByUserId(@Validated @RequestBody AllMasterOptionsRequest request) {
+		ResponseModel response = complainService.viewAllComplaintsByUserId(request);
+		return ResponseEntity.ok(response);
+	}
+}

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

@@ -1,24 +1,151 @@
 package com.billpaymentservice.bbps.controller;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.CrossOrigin;
 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.BillerDetailRequest;
+import com.billpaymentservice.bbps.dto.request.ContactMasterRequest;
+import com.billpaymentservice.bbps.dto.request.CustomParamRequest;
+import com.billpaymentservice.bbps.dto.request.DispositionRequest;
+import com.billpaymentservice.bbps.dto.request.LoginRequest;
+import com.billpaymentservice.bbps.dto.request.MasterCategoryRequest;
+import com.billpaymentservice.bbps.dto.request.MasterRequest;
+import com.billpaymentservice.bbps.dto.request.PlanRequest;
+import com.billpaymentservice.bbps.dto.response.AuthResponses;
 import com.billpaymentservice.bbps.service.MasterDataService;
 
+import jakarta.validation.Valid;
+
+@RequestMapping("/masterData")
 @RestController
+@Validated
+@CrossOrigin(origins = "*")
 public class MasterDataController {
 
+	private static final Logger log = LoggerFactory.getLogger(MasterDataController.class);
+
 	private final MasterDataService masterDataService;
 
 	public MasterDataController(MasterDataService masterDataService) {
 		this.masterDataService = masterDataService;
 	}
 
-    @PostMapping("/getBillerById")
-    public String getBillerById(@RequestBody BillerDetailRequest billerRequestRequest) {
-        masterDataService.getBillerByBillerId(billerRequestRequest);
-        return "Abc";
+	/** Get Details of the biller by billId **/
+	@PostMapping(value = "/getBillerDetails", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getBillerDetails(@Valid @RequestBody BillerDetailRequest billerDetailRequest) {
+
+		log.info("Received biller details request for billerId: {}", billerDetailRequest.getBillerId());
+
+		return ResponseEntity.ok(masterDataService.getBillerByBillerId(billerDetailRequest));
 	}
+
+	/** Get Master Contact **/
+	@PostMapping(value = "/getContactMasterResponse", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getContactMaster(
+			@Validated @RequestBody ContactMasterRequest contactMasterRequest) {
+
+		return ResponseEntity.ok(masterDataService.getContactMaster(contactMasterRequest));
+	}
+
+	@PostMapping(value = "/getDispostionDetail", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getDispostionDetail(
+			@Validated @RequestBody DispositionRequest dispositionDetailRequest) {
+		return ResponseEntity.ok(masterDataService.getDispositionDetails(dispositionDetailRequest));
+	}
+
+	@PostMapping(value = "/getTicketDispositions", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getTicketDispositions(
+			@Validated @RequestBody DispositionRequest dispositionDetailRequest) {
+		return ResponseEntity.ok(masterDataService.getTicketDispositions(dispositionDetailRequest));
+	}
+
+	/**
+	 * Get CustomerParam by billerId.The parameter is different from the data we are
+	 * getting in the billerDetail
+	 **/
+
+	@PostMapping(value = "/getCustomerParamDetails", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getCustomerParamDetails(
+			@Validated @RequestBody CustomParamRequest customerParamRequest) {
+
+		log.info("Received biller details request for billerId: {}", customerParamRequest.getBillerId());
+
+		return ResponseEntity.ok(masterDataService.getCustomerParamByBillerId(customerParamRequest));
+	}
+
+	/**
+	 * Get All Master Data .The parameter is different from the data we are getting
+	 * Made By Arham in the MasterRequest
+	 **/
+	@PostMapping("/getAllMastersData")
+	public ResponseModel fetchMasterData(@Validated @RequestBody MasterRequest masterRequest) {
+		return masterDataService.getMasterData(masterRequest);
+	}
+
+	/**
+	 * POST Master CategoryResponseList Wise API Fetch CategoryResponseList Wise
+	 * from BBPS URL Made By Arham
+	 **/
+	@PostMapping(value = "/getMasterCategoryWise", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getMasterDataCategoryWise(
+			@Valid @RequestBody MasterCategoryRequest masterRequest) {
+		return ResponseEntity.ok(masterDataService.fetchMasterDataCategoryWise(masterRequest));
+	}
+
+	/**
+	 * POST Customer Param Groups API Fetch CategoryResponseList Wise from BBPS URL
+	 * Made By Arham
+	 **/
+	@PostMapping(value = "/customerParamGroupsByBillerId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getCustomerParamGroup(
+			@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchCustomerParamGroup(requestModel));
+	}
+
+	/**
+	 * POST Fetch All AMount Options By Biller Id API Fetch CategoryResponseList
+	 * Wise from BBPS URL Made By Arham
+	 **/
+	@PostMapping(value = "/fetchAmountOptionsByBillerId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchAllMasterAmountOptionsByBillerId(
+			@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchAllMasterAmountOption(requestModel));
+	}
+
+	/**
+	 * POST Fetch All AMount Options By Biller Id API Fetch CategoryResponseList
+	 * Wise from BBPS URL Made By Arham
+	 **/
+	@PostMapping(value = "/fetchAllPlanCategoriesByBillerId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchPlanCategories(@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchPlanCategorie(requestModel));
+	}
+
+	/**
+	 * POST Fetch Initiating Channel API Fetch CategoryResponseList Wise from BBPS
+	 * URL Made By Arham
+	 **/
+	@PostMapping(value = "/initiatingChannel", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> initiatingChannel(@Validated @RequestBody BillerDetailRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchInitiatingChannel(requestModel));
+	}
+
+	/**
+	 * POST Fetch All AMount Options By Biller Id API Fetch CategoryResponseList
+	 * Wise from BBPS Made By Arham URL
+	 **/
+	@PostMapping(value = "/fetchPlanByCategoryName", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> fetchPlanByCategory(@Validated @RequestBody PlanRequest requestModel) {
+		return ResponseEntity.ok(masterDataService.fetchPlanByCategories(requestModel));
+	}
+
 }

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

@@ -0,0 +1,65 @@
+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.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.BillPaymentRequest;
+import com.billpaymentservice.bbps.dto.request.TransactionStatusRequest;
+import com.billpaymentservice.bbps.dto.request.TrasactionStatusByClientReqIdRequest;
+import com.billpaymentservice.bbps.dto.response.TransactionStatusResponse;
+import com.billpaymentservice.bbps.service.PaymentService;
+import com.billpaymentservice.bbps.service.PaymentStartService;
+import com.billpaymentservice.bbps.dto.request.PaymentStartUserRequest;
+
+@RestController
+@RequestMapping("/agent/payment")
+public class PaymentController {
+
+	/**
+	 * Fetches bill details from external BBPS service
+	 */
+
+	private final PaymentService paymentService;
+	private final PaymentStartService paymentStartService;
+
+	// New constructor used by Spring to inject both services
+	public PaymentController(PaymentService paymentService, PaymentStartService paymentStartService) {
+		this.paymentService = paymentService;
+		this.paymentStartService = paymentStartService;
+	}
+
+	@PostMapping(value = "/intiatePayment", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> requestBillFetch(
+			@Validated @RequestBody BillPaymentRequest billPaymentRequest) {
+
+		ResponseModel response = paymentService.initiatePayment(billPaymentRequest);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping(value = "/checkTransactionStatus", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> checkTransactionStatus(
+			@Validated @RequestBody TransactionStatusRequest transactionStatusRequest) {
+
+		ResponseModel response = paymentService.checkTrasactionStatus(transactionStatusRequest);
+		return ResponseEntity.ok(response);
+	}
+
+	@PostMapping(value = "/checkTransactionStatusByClientReqId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> checkTransactionStatusByClientReqId(
+			@Validated @RequestBody TrasactionStatusByClientReqIdRequest transactionStatusRequest) {
+
+		ResponseModel response = paymentService.checkTrasactionStatusByClientReqId(transactionStatusRequest);
+		return ResponseEntity.ok(response);
+	}
+	
+	
+	
+	
+	
+}

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

@@ -0,0 +1,53 @@
+package com.billpaymentservice.bbps.controller;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+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.PaymentStartUserRequest;
+import com.billpaymentservice.bbps.dto.request.CallbackRequest;
+import com.billpaymentservice.bbps.service.PaymentStartService;
+
+@RestController
+@RequestMapping("/payment")
+public class PaymentStartController {
+	private final PaymentStartService paymentStartService;
+
+	public PaymentStartController(PaymentStartService paymentStartService) {
+		this.paymentStartService = paymentStartService;
+	}
+	
+	@PostMapping(value = "/startWebPayment", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<ResponseModel> startWebPayment(@Validated @RequestBody PaymentStartUserRequest paymentStartUserRequest) {
+      
+        ResponseModel response = paymentStartService.startWebPayment(paymentStartUserRequest);
+        return ResponseEntity.ok(response);
+    }
+
+	@PostMapping(value = "/callback/startPayment", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<Map<String, String>> handleCallback(@RequestBody CallbackRequest callbackRequest) {
+		ResponseModel resp = paymentStartService.handleStartCallback(callbackRequest);
+		Map<String, String> result = new HashMap<>();
+		// Use the status field from ResponseModel as merchant status code string
+		result.put("status", resp.getStatus());
+		return ResponseEntity.ok(result);
+	}
+	
+	@PostMapping(value = "/startIntentPayment", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<ResponseModel> startIntentPayment(@Validated @RequestBody PaymentStartUserRequest paymentStartUserRequest) {
+        if (this.paymentStartService == null) {
+            // Defensive: if bean not injected, return failure
+            return ResponseEntity.badRequest().body(new ResponseModel("PaymentStartService not available", "FAILED", 400, null));
+        }
+        ResponseModel response = paymentStartService.startIntentPayment(paymentStartUserRequest);
+        return ResponseEntity.ok(response);
+    }
+}

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

@@ -0,0 +1,47 @@
+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.CrossOrigin;
+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.PaymentHistoryByTxnRequest;
+import com.billpaymentservice.bbps.dto.request.PaymentHistoryRequest;
+import com.billpaymentservice.bbps.service.TxnHistoryService;
+
+import lombok.extern.slf4j.Slf4j;
+
+@RestController
+@RequestMapping("/history")
+@CrossOrigin(origins = "*")
+@Slf4j
+public class TxnHistoryController {
+
+	private final TxnHistoryService txnHistory;
+
+	public TxnHistoryController(TxnHistoryService txnHistory) {
+		this.txnHistory = txnHistory;
+
+	}
+
+	@PostMapping(value = "/paymentHistoryDetails", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getPaymentHistory(
+			@Validated @RequestBody PaymentHistoryRequest paymentHistoryRequest) {
+
+		ResponseModel response = txnHistory.getPaymentHistoryDetails(paymentHistoryRequest);
+		return ResponseEntity.ok(response);
+	}
+	
+	@PostMapping(value = "/paymentHistoryByTxnId", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+	public ResponseEntity<ResponseModel> getPaymentHistoryByTxnId(
+			@Validated @RequestBody PaymentHistoryByTxnRequest request) {
+
+		ResponseModel response = txnHistory.getPaymentHistoryDetailsByTxnId(request);
+		return ResponseEntity.ok(response);
+	}
+}

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

@@ -0,0 +1,20 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+import java.util.UUID;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class AdditionalInfo {
+
+	private UUID planAdditionalInfoId;
+	private List<PlanTag> tags;
+
+}

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

@@ -0,0 +1,16 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class AdditionalInfoBillDTO {
+	   private String additionalInfoId;
+	   private String name;
+	   private String value;
+}

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

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

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

@@ -0,0 +1,19 @@
+package com.billpaymentservice.bbps.dto;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class AdditionalInfoDTO {
+    @NotBlank(message = "Param Config ID cannot be blank")
+    private String paramConfigId;
+
+    @NotBlank(message = "Param name cannot be blank")
+    private String paramName;
+
+    private String dataTypeDAO;
+    private String dataTypeModel;
+    private boolean optional;
+    private boolean visibility;
+}

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

@@ -0,0 +1,22 @@
+package com.billpaymentservice.bbps.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class AgentFundTransfer {
+    @NotBlank private String fundTxnReferenceId;
+    @NotBlank private String fundTxnRemarks;
+    @NotBlank private String fundTxnDate;
+    @NotNull private Double fundTxnAmt;
+    @NotBlank private String fundUTR;
+
+    private String fundRespRemarks;
+    private String agentNpciId;
+    private String txnRefId;
+    private String tenantId;
+    @NotBlank private String fundStatus; // FUND_TRANSFER_SUCCESS or FUND_TRANSFER_FAILED
+}

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

@@ -0,0 +1,12 @@
+package com.billpaymentservice.bbps.dto;
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class AmountOptionDTO{
+   private String amountOptionId;            // Matches "amountOptionId" from JSON
+    private List<String> amountBreakupSets;              // Reference to BillerResponseParams (only ID, not full entity)
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class BillerAdditonalInfoDTO {
+	  private String paramConfigId;
+      private String paramName;
+      private String dataTypeDAO;
+	  private String dataTypeModel;
+	  private boolean optional;
+	  private boolean visibility;
+}

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

@@ -0,0 +1,112 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.entites.AdditionalInfoBillValidate;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class BillerDTO {
+
+    @NotBlank(message = "Biller ID is mandatory")
+    @Size(min = 14, max = 14, message = "Biller ID must be 14 characters long")
+    private String billerId;
+
+    @NotBlank(message = "Biller name cannot be blank")
+    private String billerName;
+
+    @NotBlank(message = "Biller alias name cannot be blank")
+    private String billerAliasName;
+
+    @NotBlank(message = "Biller category name cannot be blank")
+    private String billerCategoryName;
+
+    @NotBlank(message = "Biller mode cannot be blank")
+    private String billerMode;
+
+    private boolean billerAcceptsAdhoc;
+
+    private boolean parentBiller;
+
+    @NotBlank(message = "Parent biller ID cannot be blank")
+    private String parentBillerId;
+
+    @NotBlank(message = "Biller ownership is required (PSU or Private)")
+    private String billerOwnerShp;
+
+    @NotBlank(message = "Biller coverage cannot be blank")
+    private String billerCoverage;
+
+    @NotBlank(message = "Fetch requirement is mandatory")
+    private String fetchRequirement;
+
+    @NotBlank(message = "Payment amount exactness is required")
+    private String paymentAmountExactness;
+
+    @NotBlank(message = "Support bill validation is required")
+    private String supportBillValidation;
+
+    @NotBlank(message = "Effective from date is required")
+    private String billerEffctvFrom;
+
+    @NotBlank(message = "Effective to date is required")
+    private String billerEffctvTo;
+
+    private String billerTempDeactivationStart;
+
+    private String billerTempDeactivationEnd;
+
+    @NotBlank(message = "Biller description cannot be blank")
+    private String billerDescription;
+
+    @NotBlank(message = "Biller response type is required (SINGLE or SELECTIVE)")
+    private String billerResponseType;
+
+    @NotBlank(message = "Plan MDM requirement cannot be blank")
+    private String planMDMRequirement;
+
+    @NotBlank(message = "Status must be ACTIVE or INACTIVE")
+    private String status;
+
+    @NotBlank(message = "Support deemed value is required (Yes/No)")
+    private String supportDeemed;
+
+    @NotBlank(message = "Support pending status is required (Yes/No)")
+    private String supportPendingStatus;
+
+    @NotBlank(message = "Biller timeout is required")
+    private String billerTimeOut;
+
+    private String routeUrl;
+
+    private String upmsEnabled;
+
+    private String clickpayEnabled;
+
+    private String deemedSuccessEnabled;
+
+    private String selectionType;
+
+    // ✅ Nested lists and objects — matching API structure
+    private List<PaymentModeDTO> billerPaymentModes;
+    private List<PaymentChannelDTO> billerPaymentChannels;
+    private List<CustomerParamDTO> billerCustomerParams;
+
+    private CustomerParamGroupsDTO customerParamGroups;
+    private BillerResponseParamsDTO billerResponseParams;
+
+    private List<AdditionalInfoDTO> billerAdditionalInfos;
+    private List<BillerAdditonalInfoDTO> billerAdditionalInfoPayments;
+
+    private List<InterchangeFeeConfDTO> interchangeFeeConves;
+    private List<InterchangeFeeDTO> interchangeFees;
+
+    private BillerPlanResponseParamsDTO billerPlanResponseParams;
+}

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

@@ -0,0 +1,17 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class BillerIconDTO {
+
+	private String icon_data; // Base64 or image data
+	private String icon_type;
+
+}

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

@@ -0,0 +1,14 @@
+package com.billpaymentservice.bbps.dto;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class BillerPlanResponseParamsDTO {
+    private String billerPlanResponseId;
+    private String paramsJson;
+    private String amountOptionsJson;
+}

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

@@ -0,0 +1,26 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class BillerResponseBill {
+	private String billId;
+    private String amount;
+    private String billDate;
+    private String billNumber;
+    private String billPeriod;
+    private String custConvFee;
+    private String couCustConvFee;
+    private String dueDate;
+    private String customerName;
+    private boolean amountOption;
+    private List<Detail> tagList; // null in response, so keeping Object
+}

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

@@ -0,0 +1,16 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class BillerResponseParamsDTO {
+
+    private String billerResponseId;
+    private List<String> params;
+    private List<AmountOptionDTO> amountOptions;
+}
+

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

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

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

@@ -0,0 +1,29 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class CheckClientBillerResponseDTO {
+
+	private String billId;
+	private String amount;
+	private String billDate;
+	private String billNumber;
+	private String billPeriod;
+	private String custConvFee;
+	private String couCustConvFee;
+	private String dueDate;
+	private String customerName;
+	private Boolean amountOption;
+
+	private List<Detail> tagList;
+
+	// Conditional fields
+	private List<BillAdditionalInfoDTO> additionalInfo; // C
+	private List<BillCustomerParamsDTO> customerParams; // C
+
+}

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

@@ -0,0 +1,36 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class CloseComplaintDTO {
+
+	private String complaintId;
+	private String complaintDescr;
+	private String complaintDispos;
+	private String complaintType;
+	private String txnId;
+	private String complaintStatus;
+	private String assignedTo;
+	private String complaintNpciId;
+	private String complaintRaisedFrom;
+	private String userId;
+	private String status;
+	private String refId;
+	private String estimatedTAT;
+	private String creationDate; // ISO 8601 format
+	private String modifiedDate; // ISO 8601 format
+	private String billerName;
+	private String txnAmount;
+	private String superLevelEsc; // True/False
+	private String openComplaint; // Y/N
+	private String reopenComplaint; // Y/N
+	private String remarks;
+	private String agentId;
+	private String category;
+	private Long createdEpochDate; // UNIX timestamp
+	private Long modifiedEpochDate; // UNIX timestamp
+
+}

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

@@ -0,0 +1,44 @@
+package com.billpaymentservice.bbps.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class ComplainDetailsDto {
+
+	@JsonProperty("TicketId")
+	private String TicketId;
+	@JsonProperty("TicketNpciId")
+	private String TicketNpciId;
+	@JsonProperty("TxnId")
+	private String TxnId;
+	@JsonProperty("TxnNpciId")
+	private String TxnNpciId;
+	@JsonProperty("TicketStatus")
+	private String TicketStatus;
+	@JsonProperty("TicketType")
+	private String TicketType;
+	@JsonProperty("TicketDespo")
+	private String TicketDespo;
+	@JsonProperty("TicketDescr")
+	private String TicketDescr;
+	@JsonProperty("TicketRaisedBy")
+	private String TicketRaisedBy;
+	@JsonProperty("CreatedTime")
+	private String CreatedTime;
+	@JsonProperty("TxnAmount")
+	private String TxnAmount;
+	@JsonProperty("TotalTxnAmount")
+	private String TotalTxnAmount;
+	@JsonProperty("BillCategory")
+	private String BillCategory;
+	@JsonProperty("BillerName")
+	private String BillerName;
+
+}

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

@@ -0,0 +1,20 @@
+package com.billpaymentservice.bbps.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class ComplaintDetailsDTO {
+	private String refId; // UUID
+	private String txnNpciId; // Complaint description
+	private String ticketId; // Complaint disposition
+	private String ticketType;
+	private String ticketNpciId; // Transaction ID
+	private String ticketDesp; // Transaction NPCI ID
+	private String ticketDesr; // Assigned person
+}

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

@@ -0,0 +1,15 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class ComplaintHistoryDTO {
+
+	private String historyId;
+	private String ticketId;
+	private String time;
+	private String historyStatus;
+
+}

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

@@ -0,0 +1,15 @@
+package com.billpaymentservice.bbps.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class ContactMaster {
+	private String mobNo;
+	@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+	private String tenantId;
+
+}

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

@@ -0,0 +1,25 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class CustomParamDTO {
+	 private String customParamName;
+     private String dataType;
+     private boolean optional;
+     private int minLength;
+     private int maxLength;
+     private String regex;
+     private boolean visibility;
+     private List<String> values;
+}

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

@@ -0,0 +1,26 @@
+package com.billpaymentservice.bbps.dto;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class CustomerParamDAO {
+     public CustomerParamDAO(String name, String value, String type) {
+		
+    	this.name = name;
+    	this.value = value;
+    	this.type = type;
+	}
+	 private String paramsId;
+     private String name;
+     private String value;
+     private String type;
+}

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

@@ -0,0 +1,28 @@
+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;
+
+@Getter
+@Setter
+public class CustomerParamDTO {
+	private String paramConfigId;
+    @NotBlank(message = "Parameter name is required")
+    private String paramName;
+    private String dataTypeDAO;
+    private String dataTypeModel;
+    private boolean optional;
+    @Min(0)
+    private int minLength;
+    @Min(0)
+    private int maxLength;
+    private String regex;
+    private boolean visibility;
+    // ✅ List of possible values
+    private List<String> values;
+
+
+}

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

@@ -0,0 +1,13 @@
+package com.billpaymentservice.bbps.dto;
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@ToString
+public class CustomerParamGroupsDTO {
+    private List<GroupDTO> groups;
+}

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

@@ -0,0 +1,16 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CustomerParamsRequest {
+	 private List<Tag> tags;
+}

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

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

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

@@ -5,10 +5,12 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import lombok.ToString;
 @Getter
 @Setter
 @NoArgsConstructor
 @AllArgsConstructor
+@ToString
 public class DeviceDetail {
 	
 	private List<Detail> detail;

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

@@ -0,0 +1,13 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+
+public class DispositionsDTO {
+	private String dispositionId;
+    private String dispositionDescr;
+    private String tenantId;
+}

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

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

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

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

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

@@ -0,0 +1,22 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class GroupDTO {
+
+	private String groupId;
+	
+	private String name;
+
+	private String input;
+
+	private List<String> params;
+
+	// 🔁 Nested child groups
+	private List<GroupDTO> groups;
+}

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

@@ -0,0 +1,27 @@
+package com.billpaymentservice.bbps.dto;
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class InterchangeFeeConfDTO {
+    @NotBlank(message = "Interchange Fee Config ID cannot be blank")
+    private String interChangeFeeConfId;
+
+    private String mti;
+    private String paymentMode;
+    private String paymentChannel;
+    private String responseCode;
+
+    private List<String> fees;
+    private boolean defaultFee;
+    private String effctvFrom;
+    private String effctvTo;
+}
+

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

@@ -0,0 +1,26 @@
+package com.billpaymentservice.bbps.dto;
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class InterchangeFeeDTO {
+    @NotBlank(message = "Interchange Fee ID cannot be blank")
+    private String interchangeFeeId;
+
+    @NotBlank(message = "Fee code is mandatory")
+    private String feeCode;
+
+    private String feeDesc;
+    private String feeDirection;
+
+    // ✅ One-to-Many relation represented by DTO list
+    private List<InterchangeFeeDetailDTO> interchangeFeeDetails;
+
+}

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

@@ -0,0 +1,23 @@
+package com.billpaymentservice.bbps.dto;
+
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class InterchangeFeeDetailDTO {
+
+    private String interchangeFeeDetId;
+
+    private long tranAmtRangeMax;
+
+    private long tranAmtRangeMin;
+
+    private double percentFee;
+
+    private double flatFee;
+
+    private String effctvFrom;
+
+}

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

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

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

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

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

@@ -0,0 +1,26 @@
+package com.billpaymentservice.bbps.dto;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class PaymentChannelDTO {
+    private String paymentChannelLimitId;  
+
+    @NotBlank(message = "Payment channel is required")
+    private String paymentChannel;
+
+    @Min(value = 0, message = "Max limit cannot be negative")
+    private long maxLimit;
+
+    @Min(value = 0, message = "Min limit cannot be negative")
+    private long minLimit;
+
+    private String supportPendingStatus;
+}
+
+
+

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

@@ -0,0 +1,30 @@
+package com.billpaymentservice.bbps.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.PositiveOrZero;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class PaymentModeDTO {
+    @NotBlank(message = "Payment model limit ID cannot be blank")
+    private String paymentModelLimitId;
+
+    @NotBlank(message = "Payment mode is mandatory")
+    private String paymentMode;
+
+    @PositiveOrZero(message = "Max limit must be zero or positive")
+    private long maxLimit;
+
+    @PositiveOrZero(message = "Min limit must be zero or positive")
+    private long minLimit;
+
+    @Pattern(regexp = "^(Yes|No)?$", message = "Support pending status must be either 'Yes' or 'No'")
+    private String supportPendingStatus;
+
+}

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

@@ -0,0 +1,15 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class PaymentStartReturnDto {
+	   private String amount;
+	   private String orderNo;
+	   private String created_on;
+	   private String qrString;
+	   private String txnId;
+
+}

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

@@ -0,0 +1,16 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class PaymentStatusDataResponse {
+   private String amount;
+   private String orderNo;
+   private String created_on;
+   private String qrString;
+   private String mid;
+   private String txnId;
+
+}

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

@@ -0,0 +1,27 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class PlanDTO {
+
+	private String planId;
+	private String description;
+	private String billerId;
+	private String categoryType;
+	private List<String> categorySubType; // comes as empty array []
+	private String amountInRupees; // numeric but mapped as String for safety
+	private String effctvFrom;
+	private String effctvTo;
+	private String status;
+	private AdditionalInfo additionalInfo;
+
+}

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

@@ -0,0 +1,20 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.UUID;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class PlanTag {
+
+	private UUID tagId;
+	private String name;
+	private String value;
+
+}

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

@@ -0,0 +1,18 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class PlansListDTO {
+	
+	private List<PlanDTO> plans;
+
+}

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

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

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

@@ -0,0 +1,46 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+public class ResponseModel<T> {
+
+	private String message;
+	private String status;
+	private int statusCode;
+	private Object data;
+	private Object duplicateData;
+	private int size;
+	
+	public ResponseModel(String message, String status, int statusCode, Object data) {
+		super();
+		this.message = message;
+		this.status = status;
+		this.statusCode = statusCode;
+		this.data = data;
+		
+	}
+	public ResponseModel(String message, String status, int statusCode, Object data,Object data1) {
+		this.message = message;
+		this.status = status;
+		this.statusCode = statusCode;
+		this.data = data;
+		this.duplicateData=data1;
+	}
+	
+	public ResponseModel(String message, String status, int statusCode, Object data, int size) {
+		super();
+		this.message = message;
+		this.status = status;
+		this.statusCode = statusCode;
+		this.data = data;
+		this.size = size;
+	}
+	
+}

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

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

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

@@ -0,0 +1,21 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Data;
+
+@Data
+public class TicketDetailsDTO {
+
+	private String ticketId;
+	private String ticketNpciId;
+	private String txnNpciId;
+	private String ticketType;
+	private String ticketDespo;
+	private String ticketDescr;
+	private String status;
+
+	private String npciTicketType;
+	private String npciTicketStatus;
+
+	private String createdTime;
+
+}

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

@@ -0,0 +1,15 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class TicketDispositionsDTO {
+
+	private String dispositionId;
+	private String dispositionDescr;
+	private String tenantId;
+	private String dispositionCode;
+
+}

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

@@ -0,0 +1,74 @@
+package com.billpaymentservice.bbps.dto;
+
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class TransactionDTO {
+   
+	@JsonProperty("txnId")
+    @NotBlank private String bankTxnId;
+    @NotBlank private String refId;
+    private String txnNpciId;
+    private String paymentRefId;
+    private String remitterName;
+
+
+    @NotBlank private String orderId;
+    @NotBlank private String billId;
+    @NotBlank private String userType;
+    @NotBlank private String userId;
+
+    @NotNull private Double txnAmount;
+    @NotNull private Double totalTxnAmount;
+
+    @NotBlank private String billerId;
+    @NotBlank private String billerCategory;
+    @NotBlank private String billerName;
+
+    private String clientReqId;
+    private String offUsPay;
+    private String splitPay;
+    private String quickPay;
+    private String paymentMode;
+    private String agentPaymentInformation;
+
+    private Double custConvFee;
+    private String currency;
+    private String status;
+    private String requestedIp;
+    private String customerMobNo;
+    private String macAddress;
+
+    private Double splitPayAmount;
+    private Double couCustConvFee;
+
+    private Boolean settlementVerification;
+    private String fundTxnType;
+    private String reason;
+
+    private String amountTags;
+    private String customerParamsDAOS;
+    private String paymentInformation;
+    private List<DeviceBlockTag> deviceBlockTags;
+    private List<CustomerParamDAO> customerParamsDAO;
+
+    private String planId;
+    private String planType;
+
+    // ✅ Date fields as String (for JSON compatibility)
+    private String creationDate;
+    private String modifiedDate;
+
+    private Long createdEpochDate;
+    private Long modifiedEpochDate;
+}

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

@@ -0,0 +1,56 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@ToString
+public class TransactionHistoryMasterDTO {
+
+	private String bankTxnId;
+	private String txnId;
+	private String clientUserId;
+	private String mid;
+	private String reqId;
+	private String refId;
+	private String txnNpciId;
+	private String paymentRefId;
+	private String remitterName;
+	private String orderId;
+	private String billId;
+	private String userType;
+	private String userId;
+	private Double txnAmount;
+	private Double totalTxnAmount;
+	private String billerId;
+	private String billerCategory;
+	private String billerName;
+	private String clientReqId;
+	private String offUsPay;
+	private String splitPay;
+	private String quickPay;
+	private String paymentMode;
+	private String agentPaymentInformation;
+	private Double custConvFee;
+	private String currency;
+	private String status;
+	private String requestedIp;
+	private String customerMobNo;
+	private String macAddress;
+	private Double splitPayAmount;
+	private Double couCustConvFee;
+	private Boolean settlementVerification;
+	private String fundTxnType;
+	private String reason;
+	private String amountTags;
+	private String paymentInformation;
+	private String planId;
+	private String planType;
+	private String creationDate;
+	private String modifiedDate;
+	private Long createdEpochDate;
+	private Long modifiedEpochDate;
+
+}

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

@@ -0,0 +1,23 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class TransactionHistoryParticularDetailsDTO {
+
+	private String billerCategory;
+
+	private String billerName;
+
+	private Double totalTxnAmount;
+
+	private String bankTxnId;
+
+	private String txnId;
+
+	private String creationDate;
+
+	private String status;
+}

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

@@ -0,0 +1,21 @@
+package com.billpaymentservice.bbps.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class UserDetailsDTO {
+
+	private String userId;
+
+	private String userEmailId;
+
+	private String userMobNo;
+
+	private String userName;
+}

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

@@ -0,0 +1,54 @@
+package com.billpaymentservice.bbps.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class ViewComplaintDTO {
+
+    @JsonProperty("TicketId")
+    private String ticketId;
+
+    @JsonProperty("TicketNpciId")
+    private String ticketNpciId;
+
+    @JsonProperty("TxnId")
+    private String txnId;
+
+    @JsonProperty("TxnNpciId")
+    private String txnNpciId;
+
+    @JsonProperty("TicketStatus")
+    private String ticketStatus;
+
+    @JsonProperty("TicketType")
+    private String ticketType;
+
+    @JsonProperty("TicketDespo")
+    private String ticketDespo;
+
+    @JsonProperty("TicketDescr")
+    private String ticketDescr;
+
+    @JsonProperty("TicketRaisedBy")
+    private String ticketRaisedBy;
+
+    @JsonProperty("CreatedTime")
+    private String creationDate;
+
+    @JsonProperty("TxnAmount")
+    private String txnAmount;
+
+    @JsonProperty("TotalTxnAmount")
+    private String totalTxnAmount;
+
+    @JsonProperty("BillCategory")
+    private String billCategory;
+
+    @JsonProperty("BillerName")
+    private String billerName;
+}

src/main/java/com/billpaymentservice/bbps/dto/auth/AuthResponse.java

@@ -0,0 +1,34 @@
+package com.billpaymentservice.bbps.dto.auth;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class AuthResponse {
+    private boolean success;
+    private String message;
+    private boolean userExists;
+    private UserDto user;
+    private String token;
+
+    public AuthResponse(boolean success, String message, boolean userExists, UserDto user) {
+        this.success = success;
+        this.message = message;
+        this.userExists = userExists;
+        this.user = user;
+    }
+    public AuthResponse(boolean success, String message, String token) {
+		this.success = success;
+		this.message = message;
+		this.token = token;
+	}
+
+}

src/main/java/com/billpaymentservice/bbps/dto/auth/LoginRequest.java

@@ -0,0 +1,19 @@
+package com.billpaymentservice.bbps.dto.auth;
+
+public class LoginRequest {
+    private String mobile;
+
+    public LoginRequest() {}
+
+    public LoginRequest(String mobile) {
+        this.mobile = mobile;
+    }
+
+    public String getMobile() {
+        return mobile;
+    }
+
+    public void setMobile(String mobile) {
+        this.mobile = mobile;
+    }
+}

src/main/java/com/billpaymentservice/bbps/dto/auth/OtpSendResponse.java

@@ -0,0 +1,29 @@
+package com.billpaymentservice.bbps.dto.auth;
+
+public class OtpSendResponse {
+    private boolean success;
+    private String message;
+
+    public OtpSendResponse() {}
+
+    public OtpSendResponse(boolean success, String message) {
+        this.success = success;
+        this.message = message;
+    }
+
+    public boolean isSuccess() {
+        return success;
+    }
+
+    public void setSuccess(boolean success) {
+        this.success = success;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+}

src/main/java/com/billpaymentservice/bbps/dto/auth/RegisterRequest.java

@@ -0,0 +1,16 @@
+package com.billpaymentservice.bbps.dto.auth;
+
+import com.billpaymentservice.bbps.dto.request.BaseClass;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class RegisterRequest extends BaseClass {
+	private String mobile;
+	private String name;
+	private String email;
+	private String registrationToken;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/auth/UserDto.java

@@ -0,0 +1,18 @@
+package com.billpaymentservice.bbps.dto.auth;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class UserDto {
+	private Long id;
+	private String mobile;
+	private String name;
+	private String email;
+
+}

src/main/java/com/billpaymentservice/bbps/dto/auth/VerifyOtpRequest.java

@@ -0,0 +1,30 @@
+package com.billpaymentservice.bbps.dto.auth;
+
+public class VerifyOtpRequest {
+    private String mobile;
+    private String otp;
+
+    public VerifyOtpRequest() {
+    }
+
+    public VerifyOtpRequest(String mobile, String otp) {
+        this.mobile = mobile;
+        this.otp = otp;
+    }
+
+    public String getMobile() {
+        return mobile;
+    }
+
+    public void setMobile(String mobile) {
+        this.mobile = mobile;
+    }
+
+    public String getOtp() {
+        return otp;
+    }
+
+    public void setOtp(String otp) {
+        this.otp = otp;
+    }
+}

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

@@ -0,0 +1,10 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class AllMasterOptionsRequest extends BaseClass {
+
+}

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

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

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

@@ -0,0 +1,60 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import com.billpaymentservice.bbps.dto.DeviceDetail;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+@JsonIgnoreProperties(ignoreUnknown = true)
+public abstract class BaseClass {
+
+	
+	@NotBlank(message = "MID cannot be null or blank")
+	private String mid;
+     
+
+	@NotBlank(message = "Secret key cannot be null or blank")
+	private String secretKey;
+	
+	@NotBlank(message = "Request ID cannot be null or blank")
+	private String reqId;
+	
+	private String clientUserId;
+	
+	private DeviceDetail deviceDetial;
+	// ✅ 10 User Defined Fields (UDF1–UDF10)
+	private String udf1;
+
+	private String udf2;
+
+	private String udf3;
+	
+	private String udf4;
+    
+	private String udf5;
+	
+	private String udf6;
+     
+	private String udf7;
+	
+	private String udf8;
+	
+	private String udf9;
+	
+	private String udf10;
+    private String udf11;
+    private String udf12;
+    private String udf13;
+    private String udf14;
+}

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

@@ -0,0 +1,18 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class BillFetchByBillIdRequest extends BaseClass {
+
+	@NotNull
+	private String billId;
+
+}

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

@@ -0,0 +1,12 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class BillFetchByClientIdRequest extends BaseClass{
+	
+	private String clientReqId;
+
+}

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

@@ -0,0 +1,32 @@
+package com.billpaymentservice.bbps.dto.request;
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class BillPaymentRequest extends BaseClass {
+
+ private String tenantId;
+ private String refId;
+ private String billId;
+ private boolean amountOptions;
+ private String paymentMode;
+ private String paymentInformation;
+ private String billerId;
+ private String billerName;
+ private String billerCategory;
+ private String macAdress;
+ private String customerMobNo;
+ private Integer txnAmount;
+ private String paymentRefId;
+ private String clientReqId;
+ private String paymentChannel;
+
+ private List<DeviceBlockTagRequest> deviceBlockTags;
+ private List<CustomerParamTagRequest> customerParamsRequest;
+ private List<RemitterIdentityRequest> remitterIdentity;
+ private List<AmountBreakRequest> amountBreakSet;
+}
+

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

@@ -0,0 +1,12 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class BillValidateByClientIdRequest extends BaseClass{
+	
+	private String clientReqId;
+
+}

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

@@ -1,9 +1,16 @@
 package com.billpaymentservice.bbps.dto.request;
 
-import com.billpaymentservice.bbps.entites.BaseClass;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
 
+@Getter
+@Setter
+@ToString(callSuper = true)
 public class BillerDetailRequest extends BaseClass{
      
+	@NotNull
 	private String billerId;
 	
 }

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

@@ -0,0 +1,31 @@
+package com.billpaymentservice.bbps.dto.request;
+
+public class CallbackRequest {
+    private String mid;
+    private String data;
+    private String signature;
+
+    public String getMid() {
+        return mid;
+    }
+
+    public void setMid(String mid) {
+        this.mid = mid;
+    }
+
+    public String getData() {
+        return data;
+    }
+
+    public void setData(String data) {
+        this.data = data;
+    }
+
+    public String getSignature() {
+        return signature;
+    }
+
+    public void setSignature(String signature) {
+        this.signature = signature;
+    }
+}

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

@@ -0,0 +1,17 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class CloseComplaintRequest extends BaseClass {
+
+	@NotBlank(message = "complaintDescr not be null")
+	private String complaintDescr;
+
+	@NotBlank(message = "complaintId not be null")
+	private String complaintId;
+
+}

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

@@ -0,0 +1,18 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class ComplainStatusRequest extends BaseClass {
+
+	@NotBlank(message = "ticketId Id cannot be null or blank")
+	private String ticketId;
+}

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

@@ -0,0 +1,15 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class ComplaintRequestDTO extends BaseClass {
+
+	private String ticketDescription; // Complaint description that the user enters
+	private String ticketDisposition; // Complaint disposition
+	private String ticketDispositionCode; // Type of complaint
+	private String txnId; // Transaction ID (optional)
+
+}

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

@@ -0,0 +1,14 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class ContactMasterRequest extends BaseClass {
+	private String category;
+}

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

@@ -0,0 +1,19 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString
+public class CustomParamRequest extends BaseClass {
+
+	@NotNull
+	private String billerId;
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+package com.billpaymentservice.bbps.dto.request;
+
+public class DispositionRequest extends BaseClass {
+   
+}

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

@@ -0,0 +1,36 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import java.util.List;
+
+import com.billpaymentservice.bbps.dto.CustomerParamsRequest;
+import com.billpaymentservice.bbps.dto.RemitterIdentity;
+import com.billpaymentservice.bbps.dto.Tag;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+public class FetchBillRequest extends BaseClass {
+
+//    private String tenantId;                 // M
+    private String billerId;                 // M
+    private String billerName;               //M
+   // private String digiledgeKey;           // M
+   // private String  agentId;                 // M
+    private String billerCategory;           // M
+    private String clientReqId;              // C
+    private String macAdress;                // C
+    private String customerMobNo;            // M
+    private String remitterName;             // O
+    private String paymentChannel;           // M
+    private List<Tag> deviceBlockTags;       // M
+    private CustomerParamsRequest customerParamsRequest; // M
+    private List<RemitterIdentity> remitterIdentity;     // O
+	
+}

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

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

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

@@ -0,0 +1,23 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class GetTicketLatestStausRequest extends BaseClass {
+
+	@NotBlank(message = "txnNpciId Id cannot be null or blank")
+	private String txnNpciId;
+
+	@NotBlank(message = "ticketId Id cannot be null or blank")
+	private String ticketId;
+
+}

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

@@ -0,0 +1,18 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+public class LoginRequest {
+
+	@NotBlank(message = "Mobile number is required")
+	@Pattern(regexp = "^[6-9]\\d{9}$", message = "Invalid mobile number. It must be 10 digits and start with 6, 7, 8, or 9.")
+	private String mobileNumber;
+
+}

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

@@ -0,0 +1,27 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MasterCategoryRequest extends BaseClass {
+
+	private String billerName;
+
+	@NotNull
+	private String category;
+
+	private Integer pageNo = 0;
+
+	@NotNull(message = "pageEnd is required")
+	@Min(value = 1, message = "pageEnd must be greater than 0")
+	private Integer pageSize;
+
+}

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

@@ -0,0 +1,11 @@
+package com.billpaymentservice.bbps.dto.request;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+
+public class MasterRequest extends BaseClass {
+
+}

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

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