Controller Example

package org.restplanner.controllers.users;

import org.restplanner.models.databasemodels.DbUser;
import org.restplanner.models.databasemodels.factorys.users.DbUserFactory;
import org.restplanner.models.restmodels.RestUser;
import org.restplanner.models.restmodels.RestLoginAnswer;
import org.restplanner.models.restmodels.RestLogoutAnswer;
import org.restplanner.models.restmodels.RestUserdata;
import org.restplanner.models.validators.userdatavalidators.UserdataValidator;
import org.restplanner.repositories.UserRepository;
import org.restplanner.utils.RetrieveUserFromSecurityContext;
import org.restplanner.utils.dbtorestconverters.users.DbUserToRestUserConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import net.bytebuddy.utility.RandomString;

@RestController
public class UserControllerImpl implements UserController {

    private int tokenLength = 50;

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private UserdataValidator userdataValidator;

    @Autowired
    private DbUserToRestUserConverter dbToRestUserConverter;

    @Autowired
    private DbUserFactory dbUserFactory;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @PostMapping("/login")
    public ResponseEntity<RestLoginAnswer> login() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        DbUser user = userRepository.findByUsername(authentication.getName());

        if(user.getApiKey() == null) {
            user.setApiKey(RandomString.make(tokenLength));
            userRepository.save(user);
        }

        RestLoginAnswer result = new RestLoginAnswer();
        result.setApiKey(user.getApiKey());
        return new ResponseEntity<RestLoginAnswer>(result, HttpStatus.OK);
    }

    @PostMapping("/user/logout")
    public RestLogoutAnswer logout() {
        DbUser user = RetrieveUserFromSecurityContext.retrieveDbUser();
        user.setApiKey(null);

        userRepository.save(user);
        return new RestLogoutAnswer();
    }

    @PostMapping("/user")
    public ResponseEntity<RestUser> createUser(@RequestBody RestUserdata registrationData) {

        String newUsername = registrationData.getUsername();
        String newPassword = registrationData.getPassword();
        String newEmail = registrationData.getEmail();

        this.userdataValidator.validateUsername(newUsername);
        this.userdataValidator.validateUsernameAvailability(newUsername);

        this.userdataValidator.validatePassword(newPassword);
        newPassword = this.passwordEncoder.encode(newPassword);

        this.userdataValidator.validateEmail(newEmail);
        this.userdataValidator.validateEmailAvailability(newEmail);

        DbUser newDbUser = this.dbUserFactory.createAndSave(newUsername, newPassword, newEmail);
        RestUser newRestUser = this.dbToRestUserConverter.convert(newDbUser);

        return new ResponseEntity<RestUser>(newRestUser, HttpStatus.CREATED);
    }

    @DeleteMapping("/user")
    public void deleteUser() {
        DbUser user = RetrieveUserFromSecurityContext.retrieveDbUser();
        this.userRepository.delete(user);
    }

    @GetMapping("/user")
    public ResponseEntity<RestUser> getUser() {
        DbUser user = RetrieveUserFromSecurityContext.retrieveDbUser();
        RestUser restUser = this.dbToRestUserConverter.convert(user);
        return new ResponseEntity<RestUser>(restUser, HttpStatus.OK);
    }

    @PutMapping("/user")
    public void updateUser(@RequestBody RestUserdata updatedData) {
        DbUser toEditUser = RetrieveUserFromSecurityContext.retrieveDbUser();

        String updatedUsername = updatedData.getUsername();
        String updatedPassword = updatedData.getPassword();
        String updatedEmail = updatedData.getEmail();

        this.userdataValidator.validateUsername(updatedUsername);
        if(this.isUsernameDifferent(toEditUser, updatedUsername))
            this.userdataValidator.validateUsernameAvailability(updatedUsername);

        this.userdataValidator.validatePassword(updatedPassword);
        updatedPassword = this.passwordEncoder.encode(updatedPassword);

        this.userdataValidator.validateEmail(updatedEmail);
        if(this.isEmailDifferent(toEditUser, updatedEmail))
            this.userdataValidator.validateEmailAvailability(updatedEmail);

        toEditUser.setUsername(updatedUsername);
        toEditUser.setPassword(updatedPassword);
        toEditUser.setEmail(updatedEmail);
        this.userRepository.save(toEditUser);
    }

    private boolean isUsernameDifferent(DbUser toEditUser, String updatedUsername) {
        return !toEditUser.getUsername().equals(updatedUsername);
    }

    private boolean isEmailDifferent(DbUser toEditUser, String updatedEmail) {
        return !toEditUser.getEmail().equals(updatedEmail);
    }
}