aswi2022code-of-duty-gitlab/backend/src/main/java/cz/zcu/kiv/backendapi/user/UserServiceImpl.java @ 0598e57d

package cz.zcu.kiv.backendapi.user;

import cz.zcu.kiv.backendapi.exception.ApiRequestException;
import cz.zcu.kiv.backendapi.user.permission.Permission;
import cz.zcu.kiv.backendapi.user.permission.PermissionDto;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

/**
 * User service implementation
 */
@Service
@Transactional
@RequiredArgsConstructor
@Slf4j
public class UserServiceImpl implements IUserService, UserDetailsService {
    /**
     * Super ADMIN name
     */
    private static final String SUPER_ADMIN_NAME = "[e-mail]";

    /**
     * Message for exception when user is not found by username
     */
    private static final String USER_NOT_FOUND = "User with username %s not found";

    /**
     * User repository
     */
    private final UserRepository userRepository;

    /**
     * Password encoder
     */
    private final BCryptPasswordEncoder bCryptPasswordEncoder;


    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        return userRepository.findByEmail(username)
                .orElseThrow(() -> {
                    log.error(String.format(USER_NOT_FOUND, username));
                    throw new UsernameNotFoundException(String.format(USER_NOT_FOUND, username));
                });
    }

    @Override
    public UserEntity getUserByName(String username) {
        return userRepository.findByEmail(username).
                orElseThrow(() -> {
                    log.error(String.format(USER_NOT_FOUND, username));
                    throw new UsernameNotFoundException(String.format(USER_NOT_FOUND, username));
                });
    }

    @Override
    public void registerNewUser(UserDto userDto) {
        log.info("Registering new user");
        if (userRepository.findByEmail(userDto.getEmail()).isPresent()) {
            log.error("Trying to register new user with username that is already taken: " + userDto.getEmail());
            throw new ApiRequestException(String.format("User with username %s already exists", userDto.getEmail()), HttpStatus.CONFLICT);
        }
        UserEntity userEntity = new UserEntity();
        convertDtoToEntity(userDto, userEntity);
        userRepository.save(userEntity);
        log.info("New user registered");
    }

    @Override
    public void updatePermissions(String username, PermissionDto permissionDto) {
        log.info("Updating permissions to user: " + username);
        UserEntity userEntity = userRepository.findByEmail(username).orElseThrow(() -> {
            log.error(String.format(USER_NOT_FOUND, username));
            throw new UsernameNotFoundException(String.format(USER_NOT_FOUND, username));
        });
        if (userEntity.isAdmin()) {
            log.error("Permissions for user with ADMIN rights can not be changed");
            throw new ApiRequestException("Permissions for user with ADMIN rights can not be changed", HttpStatus.BAD_REQUEST);
        }
        userEntity.setPermissions(getPermissionsFromDto(permissionDto));
        userRepository.save(userEntity);
        log.info("Permissions to user " + username + " updated");
    }

    @Override
    public void resetPassword(String username, String newPassword) {
        log.info("Resetting password to user " + username);
        if (username.equals(SUPER_ADMIN_NAME)) {
            log.error("Password for SUPER ADMIN can not be changed");
            throw new ApiRequestException("Password for SUPER ADMIN can not be changed", HttpStatus.BAD_REQUEST);
        }
        UserEntity userEntity = userRepository.findByEmail(username).orElseThrow(() -> {
            log.error(String.format(USER_NOT_FOUND, username));
            throw new UsernameNotFoundException(String.format(USER_NOT_FOUND, username));
        });
        userEntity.setPassword(bCryptPasswordEncoder.encode(newPassword));
        userRepository.save(userEntity);
        log.info("Password to user " + username + " reset");
    }

    @Override
    public void deleteUser(String username) {
        log.info("Deleting user " + username);
        UserEntity userEntity = userRepository.findByEmail(username).orElseThrow(() -> {
            log.error(String.format(USER_NOT_FOUND, username));
            throw new UsernameNotFoundException(String.format(USER_NOT_FOUND, username));
        });
        if (userEntity.isAdmin()) {
            log.error("User with ADMIN rights can not be deleted");
            throw new ApiRequestException("User with ADMIN rights can not be deleted", HttpStatus.BAD_REQUEST);
        }
        userRepository.delete(userEntity);
        log.info("User " + username + " deleted");
    }

    @Override
    public List<UserDto> getAllUsers() {
        return userRepository.findAll().stream().filter(u -> !u.getEmail().equals(SUPER_ADMIN_NAME)).map(this::convertEntityToDto).collect(Collectors.toList());
    }

    @Override
    public void changePassword(String oldPassword, String newPassword) {
        log.info("Changing password to logged user");
        UserEntity loggedUser = getUserByName((String) SecurityContextHolder.getContext().getAuthentication().getPrincipal());
        if (loggedUser.getEmail().equals(SUPER_ADMIN_NAME)) {
            throw new ApiRequestException("Can not change password for SUPER ADMIN", HttpStatus.BAD_REQUEST);
        }
        if (!bCryptPasswordEncoder.matches(oldPassword, loggedUser.getPassword())) {
            throw new ApiRequestException("Old password does not match", HttpStatus.BAD_REQUEST);
        }
        loggedUser.setPassword(bCryptPasswordEncoder.encode(newPassword));
        userRepository.save(loggedUser);
        log.info("Password to logged user changed");
    }


    /**
     * Converts user DTO to user entity
     *
     * @param userDto    user DTO
     * @param userEntity user entity
     */
    private void convertDtoToEntity(UserDto userDto, UserEntity userEntity) {
        userEntity.setName(userDto.getName());
        userEntity.setEmail(userDto.getEmail());
        userEntity.setPermissions(getPermissionsFromDto(userDto.getPermissions()));
        userEntity.setPassword(bCryptPasswordEncoder.encode(userDto.getPasswords().getPassword()));
    }

    /**
     * Converts user entity to user DTO
     *
     * @param userEntity user entity
     * @return user DTO from user entity
     */
    private UserDto convertEntityToDto(UserEntity userEntity) {
        UserDto userDto = new UserDto();
        userDto.setName(userEntity.getName());
        userDto.setEmail(userEntity.getEmail());
        setPermissionsToDto(userDto, userEntity);
        return userDto;
    }

    /**
     * Sets permission to user DTO based on user entity
     *
     * @param userDto    user DTO
     * @param userEntity user entity
     */
    private void setPermissionsToDto(UserDto userDto, UserEntity userEntity) {
        byte userPermissions = userEntity.getPermissions();
        PermissionDto permissionDto = new PermissionDto();
        if ((userPermissions & Permission.READ.getBit()) == Permission.READ.getBit()) {
            permissionDto.setCanRead(true);
        }
        if ((userPermissions & Permission.WRITE.getBit()) == Permission.WRITE.getBit()) {
            permissionDto.setCanWrite(true);
        }
        if ((userPermissions & Permission.DELETE.getBit()) == Permission.DELETE.getBit()) {
            permissionDto.setCanDelete(true);
        }
        userDto.setPermissions(permissionDto);
    }

    /**
     * Returns permissions as byte from permission DTO
     *
     * @param permissionDto permission DTO
     * @return permissions as byte
     */
    private byte getPermissionsFromDto(PermissionDto permissionDto) {
        byte permissions = (byte) 0;
        if (permissionDto.isCanRead()) {
            permissions |= Permission.READ.getBit();
        }
        if (permissionDto.isCanWrite()) {
            permissions |= Permission.WRITE.getBit();
        }
        if (permissionDto.isCanDelete()) {
            permissions |= Permission.DELETE.getBit();
        }
        return permissions;
    }
}