Resolved conflicts

src/main/java/net/gepafin/tendermanagement/dao/RegionDao.java

@@ -3,21 +3,17 @@ package net.gepafin.tendermanagement.dao;
 import net.gepafin.tendermanagement.config.Translator;
 import net.gepafin.tendermanagement.constants.GepafinConstant;
 import net.gepafin.tendermanagement.entities.RegionEntity;
-import net.gepafin.tendermanagement.entities.RoleEntity;
 import net.gepafin.tendermanagement.model.request.RegionReq;
-import net.gepafin.tendermanagement.model.request.RoleReq;
 import net.gepafin.tendermanagement.model.response.RegionResponseBean;
-import net.gepafin.tendermanagement.model.request.UpdateRegionReq;
-import net.gepafin.tendermanagement.model.response.RoleResponseBean;
 import net.gepafin.tendermanagement.repositories.RegionRepository;
 import net.gepafin.tendermanagement.util.Utils;
 import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
 import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Repository;
 
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -25,14 +21,19 @@ import static net.gepafin.tendermanagement.util.ObjectUtils.setIfUpdated;
 
 @Repository
 public class RegionDao {
+    private final Logger log = LoggerFactory.getLogger(RegionDao.class);
+
     @Autowired
-    private  RegionRepository regionRepository;
+    private RegionRepository regionRepository;
 
     public RegionResponseBean createRegion(RegionReq regionReq) {
+        log.info("Creating new region with details: {}", regionReq);
         RegionEntity regionEntity = convertRegionRequestToRegionEntity(regionReq);
-        regionRepository.save(regionEntity);
+        regionEntity = regionRepository.save(regionEntity);
+        log.info("Region created with ID: {}", regionEntity.getId());
         return convertRegionEntityToRegionResponse(regionEntity);
     }
+
     private RegionEntity convertRegionRequestToRegionEntity(RegionReq regionReq) {
         RegionEntity regionEntity = new RegionEntity();
         regionEntity.setCountry(regionReq.getCountry());
@@ -50,7 +51,8 @@ public class RegionDao {
         regionEntity.setEducationLevel(regionReq.getEducationLevel());
         return regionEntity;
     }
-    private RegionResponseBean convertRegionEntityToRegionResponse(RegionEntity regionEntity) {
+
+    public RegionResponseBean convertRegionEntityToRegionResponse(RegionEntity regionEntity) {
         RegionResponseBean regionResponseBean = new RegionResponseBean();
         regionResponseBean.setId(regionEntity.getId());
         regionResponseBean.setCreatedDate(regionEntity.getCreatedDate());
@@ -72,7 +74,11 @@ public class RegionDao {
     }
 
     public RegionResponseBean updateRegion(Long id, RegionReq regionReq) {
+        log.info("Updating region with ID: {}", id);
         RegionEntity existingRegion = getRegionById(id);
+        log.info("Current region details: {}", existingRegion);
+        log.info("New region details: {}", regionReq);
+
         setIfUpdated(existingRegion::getRegionName, existingRegion::setRegionName, regionReq.getRegionName());
         setIfUpdated(existingRegion::getDescription, existingRegion::setDescription, regionReq.getDescription());
         setIfUpdated(existingRegion::getCountry, existingRegion::setCountry, regionReq.getCountry());
@@ -82,28 +88,40 @@ public class RegionDao {
         setIfUpdated(existingRegion::getAreaSize, existingRegion::setAreaSize, regionReq.getAreaSize());
         setIfUpdated(existingRegion::getGdp, existingRegion::setGdp, regionReq.getGdp());
         setIfUpdated(existingRegion::getUnemploymentRate, existingRegion::setUnemploymentRate, regionReq.getUnemploymentRate());
-        setIfUpdated(existingRegion::getInfrastructureScore, existingRegion::setInfrastructureScore, regionReq.getInfrastructureScore() );
+        setIfUpdated(existingRegion::getInfrastructureScore, existingRegion::setInfrastructureScore, regionReq.getInfrastructureScore());
         setIfUpdated(existingRegion::getEducationLevel, existingRegion::setEducationLevel, regionReq.getEducationLevel());
         setIfUpdated(existingRegion::getHealthcareAccess, existingRegion::setHealthcareAccess, regionReq.getHealthcareAccess());
         setIfUpdated(existingRegion::getEnvironmentalScore, existingRegion::setEnvironmentalScore, regionReq.getEnvironmentalScore());
-        regionRepository.save(existingRegion);
+
+        existingRegion = regionRepository.save(existingRegion);
+
+        log.info("Region updated with ID: {}", existingRegion.getId());
         return Utils.convertObject(existingRegion, RegionResponseBean.class);
     }
-    public RegionEntity getRegionById(Long id) {
-        return regionRepository.findById(id)
-                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.REGION_NOT_FOUND_MSG)));
-    }
-    public void deleteById(Long id) {
 
+    public RegionEntity getRegionById(Long id) {
+        log.info("Fetching region with ID: {}", id);
+        RegionEntity regionEntity = regionRepository.findById(id)
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.REGION_NOT_FOUND_MSG)));
+        log.info("Region found: {}", regionEntity);
+        return regionEntity;
+    }
+
+    public void deleteById(Long id) {
+        log.info("Deleting region with ID: {}", id);
         regionRepository.findById(id)
                 .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.REGION_NOT_FOUND_MSG)));
         regionRepository.deleteById(id);
+        log.info("Region deleted with ID: {}", id);
     }
-    public List<RegionResponseBean> getAllRegions()
-    {
-        return regionRepository.findAll()
+
+    public List<RegionResponseBean> getAllRegions() {
+        log.info("Fetching all regions");
+        List<RegionResponseBean> regions = regionRepository.findAll()
                 .stream()
                 .map(regionEntity -> Utils.convertObject(regionEntity, RegionResponseBean.class))
                 .collect(Collectors.toList());
+        log.info("Total regions found: {}", regions.size());
+        return regions;
     }
 }

src/main/java/net/gepafin/tendermanagement/dao/RoleDao.java

@@ -4,12 +4,15 @@ import net.gepafin.tendermanagement.config.Translator;
 import net.gepafin.tendermanagement.constants.GepafinConstant;
 import net.gepafin.tendermanagement.entities.RoleEntity;
 import net.gepafin.tendermanagement.model.request.RoleReq;
+import net.gepafin.tendermanagement.model.response.RegionResponseBean;
 import net.gepafin.tendermanagement.model.response.RoleResponseBean;
 import net.gepafin.tendermanagement.repositories.RoleRepository;
 import net.gepafin.tendermanagement.service.RegionService;
 import net.gepafin.tendermanagement.util.Utils;
 import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
 import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -20,61 +23,88 @@ import static net.gepafin.tendermanagement.util.ObjectUtils.setIfUpdated;
 
 @Component
 public class RoleDao {
+    private final Logger log = LoggerFactory.getLogger(RoleDao.class);
 
     @Autowired
     private RoleRepository roleRepository;
+
     @Autowired
     private RegionService regionService;
 
+    @Autowired
+    private RegionDao regionDao;
+
     public RoleResponseBean createRole(RoleReq roleReq) {
+        log.info("Creating new role with details: {}", roleReq);
         RoleEntity roleEntity = convertRoleRequestToRoleEntity(roleReq);
         roleEntity = roleRepository.save(roleEntity);
+        log.info("Role created with ID: {}", roleEntity.getId());
         return convertRoleEntityToRoleResponse(roleEntity);
     }
+
     private RoleEntity convertRoleRequestToRoleEntity(RoleReq roleReq) {
         RoleEntity roleEntity = new RoleEntity();
         roleEntity.setRoleName(roleReq.getRoleName());
         roleEntity.setPermissions(roleReq.getPermissions());
-        roleEntity.setDescription(roleEntity.getDescription());
+        roleEntity.setDescription(roleReq.getDescription());
         roleEntity.setRegion(regionService.getRegionById(roleReq.getRegionId()));
         return roleEntity;
     }
-    private RoleResponseBean convertRoleEntityToRoleResponse(RoleEntity roleEntity) {
-       RoleResponseBean roleResponseBean=new RoleResponseBean();
-       roleResponseBean.setId(roleEntity.getId());
-       roleResponseBean.setCreatedDate(roleEntity.getCreatedDate());
-       roleResponseBean.setUpdatedDate(roleEntity.getUpdatedDate());
-       roleResponseBean.setRoleName(roleEntity.getRoleName());
-       roleResponseBean.setDescription(roleEntity.getDescription());
-       roleResponseBean.setPermissions(roleEntity.getPermissions());
-       roleResponseBean.setRegion(roleEntity.getRegion());
+
+    public RoleResponseBean convertRoleEntityToRoleResponse(RoleEntity roleEntity) {
+        RoleResponseBean roleResponseBean = new RoleResponseBean();
+        roleResponseBean.setId(roleEntity.getId());
+        roleResponseBean.setCreatedDate(roleEntity.getCreatedDate());
+        roleResponseBean.setUpdatedDate(roleEntity.getUpdatedDate());
+        roleResponseBean.setRoleName(roleEntity.getRoleName());
+        roleResponseBean.setDescription(roleEntity.getDescription());
+        roleResponseBean.setPermissions(roleEntity.getPermissions());
+        RegionResponseBean regionResponseBean = regionDao.convertRegionEntityToRegionResponse(roleEntity.getRegion());
+        roleResponseBean.setRegion(regionResponseBean);
         return roleResponseBean;
     }
-    public RoleResponseBean updateRole(Long id, RoleReq roleReq) {
 
-        RoleEntity existingUserRole = getRoleById(id);
-        setIfUpdated(existingUserRole::getRoleName, existingUserRole::setRoleName, roleReq.getRoleName());
-        setIfUpdated(existingUserRole::getDescription, existingUserRole::setDescription, roleReq.getDescription());
-        setIfUpdated(existingUserRole::getPermissions, existingUserRole::setPermissions, roleReq.getPermissions());
-        roleRepository.save(existingUserRole);
-        return Utils.convertObject(existingUserRole, RoleResponseBean.class);
+    public RoleResponseBean updateRole(Long id, RoleReq roleReq) {
+        log.info("Updating role with ID: {}", id);
+        RoleEntity existingRole = getRoleById(id);
+
+        // Log changes before update
+        log.info("Current role details: {}", existingRole);
+        log.info("New role details: {}", roleReq);
+
+        setIfUpdated(existingRole::getRoleName, existingRole::setRoleName, roleReq.getRoleName());
+        setIfUpdated(existingRole::getDescription, existingRole::setDescription, roleReq.getDescription());
+        setIfUpdated(existingRole::getPermissions, existingRole::setPermissions, roleReq.getPermissions());
+
+        existingRole = roleRepository.save(existingRole);
+
+        log.info("Role updated with ID: {}", existingRole.getId());
+        return Utils.convertObject(existingRole, RoleResponseBean.class);
     }
 
     public RoleEntity getRoleById(Long id) {
-       return roleRepository.findById(id)
+        log.info("Fetching role with ID: {}", id);
+        RoleEntity roleEntity = roleRepository.findById(id)
                 .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.ROLE_NOT_FOUND)));
+        log.info("Role found: {}", roleEntity);
+        return roleEntity;
     }
 
     public void deleteById(Long id) {
+        log.info("Deleting role with ID: {}", id);
         roleRepository.findById(id)
-                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,Translator.toLocale(GepafinConstant.ROLE_NOT_FOUND)));
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.ROLE_NOT_FOUND)));
         roleRepository.deleteById(id);
+        log.info("Role deleted with ID: {}", id);
     }
 
     public List<RoleResponseBean> getAllRoles() {
-        return roleRepository.findAll()
+        log.info("Fetching all roles");
+        List<RoleResponseBean> roles = roleRepository.findAll()
                 .stream()
                 .map(roleEntity -> Utils.convertObject(roleEntity, RoleResponseBean.class))
                 .collect(Collectors.toList());
+        log.info("Total roles found: {}", roles.size());
+        return roles;
     }
 }

src/main/java/net/gepafin/tendermanagement/dao/UserDao.java

@@ -4,39 +4,73 @@ import net.gepafin.tendermanagement.config.Translator;
 import net.gepafin.tendermanagement.constants.GepafinConstant;
 import net.gepafin.tendermanagement.entities.RoleEntity;
 import net.gepafin.tendermanagement.entities.UserEntity;
+import net.gepafin.tendermanagement.model.request.LoginReq;
 import net.gepafin.tendermanagement.model.request.UpdateUserReq;
 import net.gepafin.tendermanagement.model.request.UserReq;
+import net.gepafin.tendermanagement.model.response.RoleResponseBean;
 import net.gepafin.tendermanagement.model.response.UserResponseBean;
+import net.gepafin.tendermanagement.model.util.JWTToken;
 import net.gepafin.tendermanagement.repositories.UserRepository;
 import net.gepafin.tendermanagement.service.RoleService;
+import net.gepafin.tendermanagement.service.impl.AuthenticationService;
 import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
 import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
 import net.gepafin.tendermanagement.web.rest.api.errors.Status;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Repository;
 
 import static net.gepafin.tendermanagement.util.ObjectUtils.setIfUpdated;
 
 @Repository
 public class UserDao {
+
+    private final Logger log = LoggerFactory.getLogger(UserDao.class);
+
     @Autowired
     private UserRepository userRepository;
 
+    @Autowired
+    private AuthenticationService authService;
+
     @Autowired
     private RoleService roleService;
 
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    @Autowired
+    private RoleDao roleDao;
+
     public UserResponseBean createUser(UserReq userReq) {
+        log.info("Creating user with email: {}", userReq.getEmail());
+        if (userRepository.existsByEmail(userReq.getEmail())) {
+            log.error("User creation failed: Email {} already exists", userReq.getEmail());
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.EMAIL_ALREADY_EXISTS));
+        }
         if (!userReq.getPassword().equals(userReq.getConfPassword())) {
-            throw new CustomValidationException(Status.VALIDATION_ERROR,Translator.toLocale(GepafinConstant.PASSWORD_DOESNT_MATCH));
+            log.error("User creation failed: Passwords do not match for email {}", userReq.getEmail());
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.PASSWORD_DOESNT_MATCH));
+        }
+        if (userReq.getPassword().length() < 8) {
+            log.error("User creation failed: Password length is less than 8 characters for email {}", userReq.getEmail());
+            throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.PASSWORD_MIN_LEN));
         }
         UserEntity userEntity = convertUserRequestToUserEntity(userReq);
         userEntity = userRepository.save(userEntity);
+        log.info("User created with ID: {}", userEntity.getId());
         return convertUserEntityToUserResponse(userEntity);
     }
 
     public UserResponseBean updateUser(Long userId, UpdateUserReq userReq) {
+        log.info("Updating user with ID: {}", userId);
         UserEntity userEntity = userRepository.findById(userId)
                 .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.REGION_NOT_FOUND_MSG)));
+        log.info("Current user details: {}", userEntity);
+        log.info("New user details: {}", userReq);
+
         setIfUpdated(userEntity::getStatus, userEntity::setStatus, userReq.getStatus());
         setIfUpdated(userEntity::getFirstName, userEntity::setFirstName, userReq.getFirstName());
         setIfUpdated(userEntity::getLastName, userEntity::setLastName, userReq.getLastName());
@@ -48,20 +82,21 @@ public class UserDao {
             setIfUpdated(userEntity::getRoleEntity, userEntity::setRoleEntity, roleEntity);
         }
         userEntity = userRepository.save(userEntity);
+        log.info("User updated with ID: {}", userEntity.getId());
         return convertUserEntityToUserResponse(userEntity);
     }
 
     private UserEntity convertUserRequestToUserEntity(UserReq userReq) {
         UserEntity userEntity = new UserEntity();
-            userEntity.setPassword(userReq.getPassword());
-            userEntity.setEmail(userReq.getEmail());
-            userEntity.setFirstName(userReq.getFirstName());
-            userEntity.setStatus(userReq.getStatus());
-            userEntity.setLastName(userReq.getLastName());
-            userEntity.setOrganization(userReq.getOrganization());
-            userEntity.setAddress(userReq.getAddress());
-            userEntity.setPhoneNumber(userReq.getPhoneNumber());
-            userEntity.setRoleEntity(roleService.getRoleById(userReq.getRoleId()));
+        userEntity.setPassword(passwordEncoder.encode(userReq.getPassword()));
+        userEntity.setEmail(userReq.getEmail());
+        userEntity.setFirstName(userReq.getFirstName());
+        userEntity.setStatus(userReq.getStatus());
+        userEntity.setLastName(userReq.getLastName());
+        userEntity.setOrganization(userReq.getOrganization());
+        userEntity.setAddress(userReq.getAddress());
+        userEntity.setPhoneNumber(userReq.getPhoneNumber());
+        userEntity.setRoleEntity(roleService.getRoleById(userReq.getRoleId()));
         return userEntity;
     }
 
@@ -70,7 +105,6 @@ public class UserDao {
         userResponseBean.setId(userEntity.getId());
         userResponseBean.setCreatedDate(userEntity.getCreatedDate());
         userResponseBean.setUpdatedDate(userEntity.getUpdatedDate());
-        userResponseBean.setId(userEntity.getId());
         userResponseBean.setEmail(userEntity.getEmail());
         userResponseBean.setFirstName(userEntity.getFirstName());
         userResponseBean.setLastName(userEntity.getLastName());
@@ -80,20 +114,32 @@ public class UserDao {
         userResponseBean.setCity(userEntity.getCity());
         userResponseBean.setCountry(userEntity.getCountry());
         userResponseBean.setStatus(userEntity.getStatus());
-        userResponseBean.setRole(userEntity.getRoleEntity());
+        RoleResponseBean roleResponseBean = roleDao.convertRoleEntityToRoleResponse(userEntity.getRoleEntity());
+        userResponseBean.setRole(roleResponseBean);
         userResponseBean.setLastLogin(userEntity.getLastLogin());
         return userResponseBean;
     }
 
     public UserResponseBean getUserById(Long id) {
+        log.info("Fetching user with ID: {}", id);
         UserEntity userEntity = userRepository.findById(id)
-                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG)));
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG)));
+        log.info("User found: {}", userEntity);
         return convertUserEntityToUserResponse(userEntity);
     }
 
     public void deleteUser(Long id) {
+        log.info("Deleting user with ID: {}", id);
         userRepository.findById(id)
-                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG)));
+                .orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG)));
         userRepository.deleteById(id);
+        log.info("User deleted with ID: {}", id);
+    }
+
+    public JWTToken login(LoginReq loginReq) {
+        log.info("User login attempt for email: {}", loginReq.getEmail());
+        JWTToken jwtToken = authService.login(loginReq);
+        log.info("Login successful for email: {}", loginReq.getEmail());
+        return jwtToken;
     }
 }