added login with otp ,verify otp and registred user

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

@@ -9,6 +9,7 @@ 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;
@@ -32,33 +33,28 @@ public class AuthController {
     }
 
     @PostMapping(value = "/sendOtp", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<OtpSendResponse> sendOtp(@Validated @RequestBody LoginRequest request) {
+    public ResponseEntity<ResponseModel> sendOtp(@Validated @RequestBody LoginRequest request) {
     	log.info("Received sendOtp request for mobile: {}", request.getMobile());
-        OtpSendResponse resp = authService.sendOtp(request);
+         return ResponseEntity.ok(authService.sendOtp(request));
-        return ResponseEntity.ok(resp);
     }
 
     @PostMapping(value = "/verifyOtp", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<AuthResponses> verifyOtp(@Validated @RequestBody VerifyOtpRequest request) {
+    public ResponseEntity<ResponseModel> verifyOtp(@Validated @RequestBody VerifyOtpRequest request) {
-        AuthResponses resp = authService.verifyOtp(request);
+    	
-        return ResponseEntity.ok(resp);
+    	 return ResponseEntity.ok(authService.verifyOtp(request));
     }
 
     @PostMapping(value = "/register", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<AuthResponse> register(@Validated @RequestBody RegisterRequest request) {
+    public ResponseEntity<ResponseModel> register(@Validated @RequestBody RegisterRequest request) {
-        AuthResponse resp = authService.registerUser(request);
+        
-        return ResponseEntity.ok(resp);
+    	return ResponseEntity.ok(authService.registerUser(request));
     }
     
     @PostMapping("/loginWithoutDecryption")
-	public ResponseEntity<AuthResponses> login(@RequestBody LoginRequest loginRequest) {
+	public ResponseEntity<ResponseModel> login(@RequestBody LoginRequest loginRequest) {
-		try {
+		
-			AuthResponses authResponse = authService.authenticateUser(loginRequest);
+			return ResponseEntity.ok(authService.authenticateUser(loginRequest));
-			return ResponseEntity.ok(authResponse);
+					
-		} catch (Exception e) {
-			return ResponseEntity.status(500).body(AuthResponses.builder().status("Unauthorized")
-					.message("An unexpected error occurred").statusCode(500).build());
-		}
 	}
     
 }

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

@@ -1,14 +1,23 @@
 package com.billpaymentservice.bbps.dto.auth;
 
-import com.billpaymentservice.bbps.dto.auth.UserDto;
+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() {}
 
     public AuthResponse(boolean success, String message, boolean userExists, UserDto user) {
         this.success = success;
@@ -16,36 +25,10 @@ public class AuthResponse {
         this.userExists = userExists;
         this.user = user;
     }
+    public AuthResponse(boolean success, String message, String token) {
+		this.success = success;
+		this.message = message;
+		this.token = token;
+	}
 
-    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;
-    }
-
-    public boolean isUserExists() {
-        return userExists;
-    }
-
-    public void setUserExists(boolean userExists) {
-        this.userExists = userExists;
-    }
-
-    public UserDto getUser() {
-        return user;
-    }
-
-    public void setUser(UserDto user) {
-        this.user = user;
-    }
 }

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

@@ -9,6 +9,6 @@ public class RegisterRequest {
     private String mobile;
     private String name;
     private String email;
-    private int  age;
+    private String  age;
 
 }

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

@@ -14,7 +14,7 @@ public class UserDto {
     private String mobile;
     private String name;
     private String email;
-    private int age;
+    private String age;
 
  
 }

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

@@ -35,7 +35,14 @@ public class UserEntity extends Auditable<String> {
     private String email;
     
     @Column(name = "age")
-    private int age;
+    private String age;
+    
+    public UserEntity(String mobile, String name, String email, String age) {
+        this.mobile = mobile;
+        this.name = name;
+        this.email = email;
+        this.age = age;
+    }
 
 
    

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

@@ -1,5 +1,6 @@
 package com.billpaymentservice.bbps.service;
 
+import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.auth.AuthResponse;
 import com.billpaymentservice.bbps.dto.auth.LoginRequest;
 import com.billpaymentservice.bbps.dto.auth.OtpSendResponse;
@@ -9,13 +10,13 @@ import com.billpaymentservice.bbps.dto.response.AuthResponses;
 import com.billpaymentservice.bbps.entites.UserEntity;
 
 public interface AuthService {
-	OtpSendResponse sendOtp(LoginRequest request);
+	ResponseModel<?> sendOtp(LoginRequest request);
 
-	AuthResponses verifyOtp(VerifyOtpRequest request);
+	ResponseModel<?> verifyOtp(VerifyOtpRequest request);
 
-	AuthResponse registerUser(RegisterRequest request);
+	ResponseModel<?> registerUser(RegisterRequest request);
 
 	UserEntity findByMobile(String mobile);
 
-	AuthResponses authenticateUser(LoginRequest loginRequest);
+	ResponseModel<?> authenticateUser(LoginRequest loginRequest);
 }

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

@@ -5,9 +5,9 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-
 import com.billpaymentservice.bbps.config.JwtUtil;
 import com.billpaymentservice.bbps.dto.UserDetailsDTO;
+import com.billpaymentservice.bbps.dto.ResponseModel;
 import com.billpaymentservice.bbps.dto.auth.AuthResponse;
 import com.billpaymentservice.bbps.dto.auth.LoginRequest;
 import com.billpaymentservice.bbps.dto.auth.OtpSendResponse;
@@ -22,147 +22,175 @@ import com.billpaymentservice.bbps.repository.UsersDetailsRepository;
 import com.billpaymentservice.bbps.service.AuthService;
 import com.billpaymentservice.bbps.util.Helper;
 import com.billpaymentservice.bbps.util.OtpClient;
-
 import java.util.Optional;
 
 @Service
 public class AuthServiceImpl implements AuthService {
 
-	private static final Logger LOGGER = LoggerFactory.getLogger(AuthServiceImpl.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(AuthServiceImpl.class);
 
-	private final UserRepository userRepository;
+    private final UserRepository userRepository;
-	private final OtpClient otpClient;
+    private final OtpClient otpClient;
-	private final Helper helper;
+    private final Helper helper;
-	private final UsersDetailsRepository userRepo;
+    private final UsersDetailsRepository userRepo;
+    private final JwtUtil jwtUtil;
 
-	private final JwtUtil jwtUtil;
+    @Autowired
+    public AuthServiceImpl(UserRepository userRepository, OtpClient otpClient, Helper helper,
+            UsersDetailsRepository userRepo, JwtUtil jwtUtil) {
+        this.userRepository = userRepository;
+        this.otpClient = otpClient;
+        this.helper = helper;
+        this.userRepo = userRepo;
+        this.jwtUtil = jwtUtil;
+    }
 
-	@Autowired
+    @Override
-	public AuthServiceImpl(UserRepository userRepository, OtpClient otpClient, Helper helper,
+    public ResponseModel<?> sendOtp(LoginRequest request) {
-			UsersDetailsRepository userRepo, JwtUtil jwtUtil) {
+        try {
-		this.userRepository = userRepository;
+            OtpSendResponse resp = otpClient.sendOtp(request.getMobile());
-		this.otpClient = otpClient;
+            if (resp == null) {
-		this.helper = helper;
+                return ResponseModel.builder()
-		this.userRepo=userRepo;
+                        .message("OTP send service returned null")
-		this.jwtUtil=jwtUtil;
+                        .status("Failure")
-	}
+                        .statusCode(500)
+                        .data(null)
+                        .build();
+            }
+            String status = resp.isSuccess() ? "Success" : "Failure";
+            int code = resp.isSuccess() ? 200 : 400;
+            return ResponseModel.builder()
+                    .message(resp.getMessage())
+                    .status(status)
+                    .statusCode(code)
+                    .data(resp)
+                    .build();
+        } catch (Exception ex) {
+            LOGGER.error("Error in sendOtp: {}", ex.getMessage(), ex);
+            return ResponseModel.builder()
+                    .message("An unexpected error occurred while sending OTP")
+                    .status("Failure")
+                    .statusCode(500)
+                    .data(null)
+                    .build();
+        }
+    }
 
-	@Override
+    @Override
-	public OtpSendResponse sendOtp(LoginRequest request) {
+    public ResponseModel<?> verifyOtp(VerifyOtpRequest request) {
-		Optional<UserEntity> existing = userRepository.findByMobile(request.getMobile());
+        boolean ok = otpClient.verifyOtp(request.getMobile(), request.getOtp());
+        LOGGER.info("OTP STATUS {}", ok);
+        if (!ok) {
+            return ResponseModel.builder()
+                    .message("Invalid OTP")
+                    .status("Failure")
+                    .statusCode(401)
+                    .data(null)
+                    .build();
+        }
+        String mobileNo = request.getMobile();
+        try {
+            Optional<UserEntity> byMobileNumber = userRepository.findByMobile(mobileNo);
 
-		if (existing.isPresent()) {
+            if (byMobileNumber.isPresent()) {
-			UserEntity u = existing.get();
+                UserEntity user = byMobileNumber.get();
-			UserDto dto = new UserDto(u.getId(), u.getMobile(), u.getName(), u.getEmail(), u.getAge());
+                String token = jwtUtil.generateToken(user.getMobile());
-			return null;
-		}
-		// delegate to external OTP provider
-		return otpClient.sendOtp(request.getMobile());
-	}
 
-	@Override
+                LOGGER.info("Generated JWT token for mobileNo: " + mobileNo);
-	public AuthResponses verifyOtp(VerifyOtpRequest request) {
-		boolean ok = otpClient.verifyOtp(request.getMobile(), request.getOtp());
-		LOGGER.info("OTP STATUS"+ ok);
-		if (ok) {
-			return new AuthResponses("","Invalid OTP","Failed", 401, null);
-		}
-		String mobileNo = request.getMobile();
-		try {
-			
 
-			Optional<UsersDetails> byAdminEmail = userRepo.findByUserMobNo(mobileNo);
+                Object userDetailsDTO = null;
 
-			if (byAdminEmail.isPresent()) {
+                if (user != null) {
-				UsersDetails user = byAdminEmail.get();
+                    userDetailsDTO = UserDetailsDTO.builder().id(user.getId()).userEmailId(user.getEmail())
-				String token = jwtUtil.generateToken(user.getUserMobNo());
+                            .userMobNo(user.getMobile()).userName(user.getName()).userAge(user.getAge())
+                            .build();
+                }
 
-				LOGGER.info("Generated JWT token for mobileNo: " + mobileNo);
+                AuthResponses authResp = new AuthResponses(token, "Success", "Login Success", 200, userDetailsDTO);
+                return ResponseModel.builder()
+                        .message("Login Success")
+                        .status("Success")
+                        .statusCode(200)
+                        .data(authResp)
+                        .build();
+            } else {
+                AuthResponses authResp = new AuthResponses("", "User Not Found", "Authentication failed", 401, null);
+                return ResponseModel.builder()
+                        .message("User Not Found")
+                        .status("Failure")
+                        .statusCode(401)
+                        .data(authResp)
+                        .build();
+            }
 
-				Object userDetailsDTO = null;
+        } catch (Exception ex) {
+            LOGGER.error("Error occurred during login for mobile no: {} Exception: {}", mobileNo, ex.getMessage(), ex);
+            return ResponseModel.builder().message("Authentication failed: " + ex.getMessage()).status("Failure")
+                    .statusCode(500).data(null).build();
+        }
+    }
 
-				if (user != null) {
+    @Override
-					userDetailsDTO = UserDetailsDTO.builder().id(user.getId()).userEmailId(user.getUserEmailId())
+    @Transactional
-							.userMobNo(user.getUserMobNo()).userName(user.getUserName()).userAge(user.getUserAge())
+    public ResponseModel<?> registerUser(RegisterRequest request) {
-							.build();
+        try {
-				}
+            Optional<UserEntity> existing = userRepository.findByMobile(request.getMobile());
-				return new AuthResponses(token, "Success", "Login Done", 200, userDetailsDTO);
+            if (existing.isPresent()) {
-			} else {
+                UserEntity u = existing.get();
-				return new AuthResponses("", "User Not Found", "Authentication failed", 401, null);
+                UserDto dto = new UserDto(u.getId(), u.getMobile(), u.getName(), u.getEmail(), u.getAge());
-			}
+                AuthResponse ar = new AuthResponse(false, "User already exists", true, dto);
+                return ResponseModel.builder().message(ar.getMessage()).status("Failure").statusCode(409).data(ar).build();
+            }
 
-		} catch (Exception ex) {
+            UserEntity newUser = new UserEntity(request.getMobile(), request.getName(), request.getEmail(), request.getAge());
-			System.out.println("Error occurred during login for mobile no: " + mobileNo
+            userRepository.save(newUser);
-					+ " Exception: " + ex.getMessage());
+            String token = jwtUtil.generateToken(newUser.getMobile());
+            UserDto dto = new UserDto(newUser.getId(), newUser.getMobile(), newUser.getName(), newUser.getEmail(), newUser.getAge());
+            AuthResponse ar = new AuthResponse(true, "user registed sucessfully", token);
+            return ResponseModel.builder().message(ar.getMessage()).status("Success").statusCode(201).data(ar).build();
+        } catch (Exception ex) {
+            LOGGER.error("Error in registerUser: {}", ex.getMessage(), ex);
+            return ResponseModel.builder().message("An unexpected error occurred while registering user").status("Failure").statusCode(500).data(null).build();
+        }
+    }
 
-			return AuthResponses.builder().status("Unauthorized").message("Authentication failed: " + ex.getMessage())
+    @Override
-					.statusCode(401).build();
+    public ResponseModel<?> authenticateUser(LoginRequest loginRequest) {
-		}
+        LOGGER.info("Processing login for Request: {}", loginRequest);
 
-//		Optional<UserEntity> userOpt = userRepository.findByMobile(request.getMobile());
+        try {
-//		if (userOpt.isPresent()) {
+            String mobileNo = loginRequest.getMobile();
-//			UserEntity user = userOpt.get();
-//			UserDto dto = new UserDto(user.getId(), user.getMobile(), user.getName(), user.getEmail(), user.getAge());
-//			return new AuthResponse(true, "Login successful", true, dto);
-//		} else {
-//			return new AuthResponse(true, "OTP verified; user not found - proceed to registration", false, null);
-//		}
-	}
 
-	@Override
+            Optional<UsersDetails> byMobileNo = userRepo.findByUserMobNo(mobileNo);
-	@Transactional
-	public AuthResponse registerUser(RegisterRequest request) {
-		Optional<UserEntity> existing = userRepository.findByMobile(request.getMobile());
-		if (existing.isPresent()) {
-			UserEntity u = existing.get();
-			UserDto dto = new UserDto(u.getId(), u.getMobile(), u.getName(), u.getEmail(), u.getAge());
-			return new AuthResponse(false, "User already exists", true, dto);
-		}
 
-		UserEntity user = helper.createNewUser(request);
+            if (byMobileNo.isPresent()) {
-		user = userRepository.save(user);
+                UsersDetails user = byMobileNo.get();
-		UserDto dto = new UserDto(user.getId(), user.getMobile(), user.getName(), user.getEmail(), user.getAge());
+                String token = jwtUtil.generateToken(user.getUserMobNo());
-		return new AuthResponse(true, "Registration successful", true, dto);
-	}
 
-	@Override
+                LOGGER.info("Generated JWT token for mobileNo: " + mobileNo);
-	public UserEntity findByMobile(String mobile) {
-		return userRepository.findByMobile(mobile).orElse(null);
-	}
 
-	@Override
+                Object userDetailsDTO = null;
-	public AuthResponses authenticateUser(LoginRequest loginRequest) {
-		LOGGER.info("Processing login for Request: " + loginRequest);
 
-		try {
+                if (user != null) {
-			String mobileNo = loginRequest.getMobile();
+                    userDetailsDTO = UserDetailsDTO.builder().id(user.getId()).userEmailId(user.getUserEmailId())
+                            .userMobNo(user.getUserMobNo()).userName(user.getUserName()).userAge(user.getUserAge())
+                            .build();
+                }
+                AuthResponses authResp = new AuthResponses(token, "Success", "Login Done", 200, userDetailsDTO);
+                return ResponseModel.builder().message("Login Done").status("Success").statusCode(200).data(authResp).build();
+            } else {
+                AuthResponses authResp = new AuthResponses("", "User Not Found", "Authentication failed", 401, null);
+                return ResponseModel.builder().message("User Not Found").status("Failure").statusCode(401).data(authResp).build();
+            }
 
-			Optional<UsersDetails> byAdminEmail = userRepo.findByUserMobNo(mobileNo);
+        } catch (Exception ex) {
+            LOGGER.error("Error occurred during login for mobile no: {} Exception: {}", loginRequest.getMobile(), ex.getMessage(), ex);
+            return ResponseModel.builder().message("Authentication failed: " + ex.getMessage()).status("Failure").statusCode(500).data(null).build();
+        }
+    }
 
-			if (byAdminEmail.isPresent()) {
+    @Override
-				UsersDetails user = byAdminEmail.get();
+    public UserEntity findByMobile(String mobile) {
-				String token = jwtUtil.generateToken(user.getUserMobNo());
+        return userRepository.findByMobile(mobile).orElse(null);
-
+    }
-				LOGGER.info("Generated JWT token for mobileNo: " + mobileNo);
-
-				Object userDetailsDTO = null;
-
-				if (user != null) {
-					userDetailsDTO = UserDetailsDTO.builder().id(user.getId()).userEmailId(user.getUserEmailId())
-							.userMobNo(user.getUserMobNo()).userName(user.getUserName()).userAge(user.getUserAge())
-							.build();
-				}
-				return new AuthResponses(token, "Success", "Login Done", 200, userDetailsDTO);
-			} else {
-				return new AuthResponses("", "User Not Found", "Authentication failed", 401, null);
-			}
-
-		} catch (Exception ex) {
-			System.out.println("Error occurred during login for mobile no: " + loginRequest.getMobile()
-					+ " Exception: " + ex.getMessage());
-
-			return AuthResponses.builder().status("Unauthorized").message("Authentication failed: " + ex.getMessage())
-					.statusCode(401).build();
-		}
-	}
 }

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

@@ -53,13 +53,6 @@ public class OtpClient {
         try {
         	logger.info("Initiating OTP send process for mobile: {}", mobile);
         	
-        	logger.info("eKYC Mobile URL: {}", ekycMobileUrl);
-        	logger.info("API Key: {}", apiKey != null && !apiKey.isEmpty());
-            logger.info("Secret Key: {}", secretKey != null && !secretKey.isEmpty());
-            logger.info("Send URL: {}", sendUrl);
-            logger.info("Verify URL: {}", verifyUrl);
-            logger.info("Mobile Number: {}", mobile);
-            
             // If explicit eKYC config present, use that flow
             if (ekycMobileUrl != null && !ekycMobileUrl.isEmpty()) {
                 HttpHeaders headers = new HttpHeaders();
@@ -145,28 +138,20 @@ public class OtpClient {
 
                     if (response.getStatusCode() == HttpStatus.OK) {
                         String respBody = response.getBody();
+
                         if (respBody != null) {
-                            // try to parse JSON and look for common verification keys
                             ObjectMapper mapper = new ObjectMapper();
-                            try {
+                            Map respMap = mapper.readValue(respBody, Map.class);
-                                Map respMap = mapper.readValue(respBody, Map.class);
+
-                                if (respMap.containsKey("verified")) {
+                            // Check correct key of your service
-                                    return Boolean.TRUE.equals(respMap.get("verified"));
+                            if (respMap.containsKey("status")) {
-                                }
+                                return Boolean.TRUE.equals(respMap.get("status"));
-                                if (respMap.containsKey("success")) {
-                                    return Boolean.TRUE.equals(respMap.get("success"));
-                                }
-                                if (respMap.containsKey("status") && "OK".equalsIgnoreCase(String.valueOf(respMap.get("status")))) {
-                                    return true;
-                                }
-                            } catch (Exception e) {
-                                logger.debug("Unable to parse verification response body to JSON: {}", e.getMessage());
-                                // fall through to treat 200 as success
                             }
                         }
-                        // fallback: treat HTTP 200 as successful verification
+
-                        return true;
+                        return false;  // default fallback
-                    } else {
+                    }
+ else {
                         logger.warn("OTP verification endpoint returned non-OK status: {}", response.getStatusCode());
                         return false;
                     }
@@ -183,4 +168,6 @@ public class OtpClient {
             return false;
         }
     }
+
+	
 }