Globots/bbps-backend
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added login with otp ,verify otp and registred user

Browse Source
This commit is contained in:
Lincpay Tech
2025-11-27 14:44:21 +05:30
parent 72332d6f99
commit a001728c4f
8 changed files with 203 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/com/billpaymentservice/bbps/controller/AuthController.java
+13 -17
View File
@@ -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(resp);
return ResponseEntity.ok(authService.sendOtp(request));
}
@PostMapping(value = "/verifyOtp", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<AuthResponses> verifyOtp(@Validated @RequestBody VerifyOtpRequest request) {
AuthResponses resp = authService.verifyOtp(request);
return ResponseEntity.ok(resp);
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<AuthResponse> register(@Validated @RequestBody RegisterRequest request) {
AuthResponse resp = authService.registerUser(request);
return ResponseEntity.ok(resp);
public ResponseEntity<ResponseModel> register(@Validated @RequestBody RegisterRequest request) {
return ResponseEntity.ok(authService.registerUser(request));
}
@PostMapping("/loginWithoutDecryption")
public ResponseEntity<AuthResponses> login(@RequestBody LoginRequest loginRequest) {
try {
AuthResponses authResponse = 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());
}
public ResponseEntity<ResponseModel> login(@RequestBody LoginRequest loginRequest) {
return ResponseEntity.ok(authService.authenticateUser(loginRequest));
}
}
src/main/java/com/billpaymentservice/bbps/dto/auth/AuthResponse.java
+17 -34
View File
@@ -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;
public AuthResponse() {}
private String token;
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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+8 -1
View File
@@ -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
+5 -4
View File
@@ -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
+146 -118
View File
@@ -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 OtpClient otpClient;
private final Helper helper;
private final UsersDetailsRepository userRepo;
private final UserRepository userRepository;
private final OtpClient otpClient;
private final Helper helper;
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
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;
}
@Override
public ResponseModel<?> sendOtp(LoginRequest request) {
try {
OtpSendResponse resp = otpClient.sendOtp(request.getMobile());
if (resp == null) {
return ResponseModel.builder()
.message("OTP send service returned null")
.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
public OtpSendResponse sendOtp(LoginRequest request) {
Optional<UserEntity> existing = userRepository.findByMobile(request.getMobile());
@Override
public ResponseModel<?> verifyOtp(VerifyOtpRequest request) {
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()) {
UserEntity u = existing.get();
UserDto dto = new UserDto(u.getId(), u.getMobile(), u.getName(), u.getEmail(), u.getAge());
return null;
}
// delegate to external OTP provider
return otpClient.sendOtp(request.getMobile());
}
if (byMobileNumber.isPresent()) {
UserEntity user = byMobileNumber.get();
String token = jwtUtil.generateToken(user.getMobile());
@Override
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 {
LOGGER.info("Generated JWT token for mobileNo: " + mobileNo);
Optional<UsersDetails> byAdminEmail = userRepo.findByUserMobNo(mobileNo);
Object userDetailsDTO = null;
if (byAdminEmail.isPresent()) {
UsersDetails user = byAdminEmail.get();
String token = jwtUtil.generateToken(user.getUserMobNo());
if (user != null) {
userDetailsDTO = UserDetailsDTO.builder().id(user.getId()).userEmailId(user.getEmail())
.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) {
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);
}
@Override
@Transactional
public ResponseModel<?> registerUser(RegisterRequest request) {
try {
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());
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) {
System.out.println("Error occurred during login for mobile no: " + mobileNo
+ " Exception: " + ex.getMessage());
UserEntity newUser = new UserEntity(request.getMobile(), request.getName(), request.getEmail(), request.getAge());
userRepository.save(newUser);
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())
.statusCode(401).build();
}
@Override
public ResponseModel<?> authenticateUser(LoginRequest loginRequest) {
LOGGER.info("Processing login for Request: {}", loginRequest);
// Optional<UserEntity> userOpt = userRepository.findByMobile(request.getMobile());
// if (userOpt.isPresent()) {
// 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);
// }
}
try {
String mobileNo = loginRequest.getMobile();
@Override
@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);
}
Optional<UsersDetails> byMobileNo = userRepo.findByUserMobNo(mobileNo);
UserEntity user = helper.createNewUser(request);
user = userRepository.save(user);
UserDto dto = new UserDto(user.getId(), user.getMobile(), user.getName(), user.getEmail(), user.getAge());
return new AuthResponse(true, "Registration successful", true, dto);
}
if (byMobileNo.isPresent()) {
UsersDetails user = byMobileNo.get();
String token = jwtUtil.generateToken(user.getUserMobNo());
@Override
public UserEntity findByMobile(String mobile) {
return userRepository.findByMobile(mobile).orElse(null);
}
LOGGER.info("Generated JWT token for mobileNo: " + mobileNo);
@Override
public AuthResponses authenticateUser(LoginRequest loginRequest) {
LOGGER.info("Processing login for Request: " + loginRequest);
Object userDetailsDTO = null;
try {
String mobileNo = loginRequest.getMobile();
if (user != null) {
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()) {
UsersDetails user = byAdminEmail.get();
String token = jwtUtil.generateToken(user.getUserMobNo());
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();
}
}
@Override
public UserEntity findByMobile(String mobile) {
return userRepository.findByMobile(mobile).orElse(null);
}
}
src/main/java/com/billpaymentservice/bbps/util/OtpClient.java
+12 -25
View File
@@ -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);
if (respMap.containsKey("verified")) {
return Boolean.TRUE.equals(respMap.get("verified"));
}
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
Map respMap = mapper.readValue(respBody, Map.class);
// Check correct key of your service
if (respMap.containsKey("status")) {
return Boolean.TRUE.equals(respMap.get("status"));
}
}
// fallback: treat HTTP 200 as successful verification
return true;
} else {
return false; // default fallback
}
else {
logger.warn("OTP verification endpoint returned non-OK status: {}", response.getStatusCode());
return false;
}
@@ -183,4 +168,6 @@ public class OtpClient {
return false;
}
}
}