ng-tracker/src/main/java/ru/ulstu/user/controller/UserController.java

package ru.ulstu.user.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.access.annotation.Secured;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import ru.ulstu.configuration.Constants;
import ru.ulstu.core.model.response.PageableItems;
import ru.ulstu.core.model.response.Response;
import ru.ulstu.odin.controller.OdinController;
import ru.ulstu.odin.model.OdinMetadata;
import ru.ulstu.odin.model.OdinVoid;
import ru.ulstu.odin.service.OdinService;
import ru.ulstu.user.model.User;
import ru.ulstu.user.model.UserDto;
import ru.ulstu.user.model.UserListDto;
import ru.ulstu.user.model.UserResetPasswordDto;
import ru.ulstu.user.model.UserRoleConstants;
import ru.ulstu.user.model.UserRoleDto;
import ru.ulstu.user.model.UserSessionListDto;
import ru.ulstu.user.service.UserService;
import ru.ulstu.user.service.UserSessionService;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.validation.Valid;

import java.util.Map;

import static ru.ulstu.user.controller.UserController.URL;

@RestController
@RequestMapping(URL)
public class UserController extends OdinController<UserListDto, UserDto> {
    public static final String URL = Constants.API_1_0 + "users";
    public static final String ROLES_URL = "/roles";
    public static final String ROLES_META_URL = ROLES_URL + OdinController.META_LIST_URL;
    public static final String SESSIONS_URL = "/sessions";
    public static final String SESSIONS_META_URL = SESSIONS_URL + OdinController.META_LIST_URL;
    public static final String REGISTER_URL = "/register";
    public static final String ACTIVATE_URL = "/activate";
    public static final String PASSWORD_RESET_REQUEST_URL = "/password-reset-request";
    public static final String PASSWORD_RESET_URL = "/password-reset";

    private final Logger log = LoggerFactory.getLogger(UserController.class);

    private final UserService userService;
    private final UserSessionService userSessionService;
    private final OdinService<UserRoleDto, UserRoleDto> odinRolesService;
    private final OdinService<UserSessionListDto, OdinVoid> odinSessionsService;

    public UserController(UserService userService,
                          UserSessionService userSessionService,
                          OdinService<UserRoleDto, UserRoleDto> odinRolesService,
                          OdinService<UserSessionListDto, OdinVoid> odinSessionsService) {
        super(UserListDto.class, UserDto.class);
        this.userService = userService;
        this.userSessionService = userSessionService;
        this.odinRolesService = odinRolesService;
        this.odinSessionsService = odinSessionsService;
    }

    @GetMapping(ROLES_URL)
    @Secured(UserRoleConstants.ADMIN)
    public Response<PageableItems<UserRoleDto>> getUserRoles() {
        log.debug("REST: UserController.getUserRoles()");
        return new Response<>(userService.getUserRoles());
    }

    @GetMapping(ROLES_META_URL)
    @Secured(UserRoleConstants.ADMIN)
    public Response<OdinMetadata> getUserRolesMetaData() {
        log.debug("REST: UserController.getUserRolesMetaData()");
        return new Response<>(odinRolesService.getListModel(UserRoleDto.class));
    }

    @GetMapping(SESSIONS_URL)
    @Secured(UserRoleConstants.ADMIN)
    public Response<PageableItems<UserSessionListDto>> getUserSessions(@RequestParam(value = "offset", defaultValue = "0") int offset,
                                                                       @RequestParam(value = "count", defaultValue = "10") int count) {
        log.debug("REST: UserController.getUserSessions()");
        return new Response<>(userSessionService.getSessions(offset, count));
    }

    @GetMapping(SESSIONS_META_URL)
    @Secured(UserRoleConstants.ADMIN)
    public Response<OdinMetadata> getUserSessionsMetaData() {
        log.debug("REST: UserController.getUserSessionsMetaData()");
        return new Response<>(odinSessionsService.getListModel(UserSessionListDto.class));
    }

    @GetMapping("")
    @Secured(UserRoleConstants.ADMIN)
    public Response<PageableItems<UserListDto>> getAllUsers(@RequestParam(value = "offset", defaultValue = "0") int offset,
                                                            @RequestParam(value = "count", defaultValue = "10") int count) {
        log.debug("REST: UserController.getAllUsers( {}, {} )", offset, count);
        return new Response<>(userService.getAllUsers(offset, count));
    }

    @GetMapping("/{userId}")
    @Secured(UserRoleConstants.ADMIN)
    public Response<UserDto> getUser(@PathVariable Integer userId) {
        log.debug("REST: UserController.getUser( {} )", userId);
        return new Response<>(userService.getUserWithRolesById(userId));
    }


    @PostMapping("")
    @Secured(UserRoleConstants.ADMIN)
    public Response<UserDto> createUser(@Valid @RequestBody UserDto userDto) {
        log.debug("REST: UserController.createUser( {} )", userDto.getLogin());
        return new Response<>(userService.createUser(userDto));
    }

    @PutMapping("")
    @Secured(UserRoleConstants.ADMIN)
    public Response<UserDto> updateUser(@Valid @RequestBody UserDto userDto) {
        log.debug("REST: UserController.updateUser( {} )", userDto.getLogin());
        return new Response<>(userService.updateUser(userDto));
    }

    @DeleteMapping("/{userId}")
    @Secured(UserRoleConstants.ADMIN)
    public Response<UserDto> deleteUser(@PathVariable Integer userId) {
        log.debug("REST: UserController.deleteUser( {} )", userId);
        return new Response<>(userService.deleteUser(userId));
    }

    @PostMapping(REGISTER_URL)
    public Response<UserDto> registerUser(@Valid @RequestBody UserDto userDto) {
        log.debug("REST: UserController.registerUser( {} )", userDto.getLogin());
        return new Response<>(userService.createUser(userDto));
    }

    @PostMapping(ACTIVATE_URL)
    public Response<UserDto> activateUser(@RequestParam("key") String activationKey) {
        log.debug("REST: UserController.activateUser( {} )", activationKey);
        return new Response<>(userService.activateUser(activationKey));
    }

    @PostMapping(PASSWORD_RESET_REQUEST_URL)
    public Response<Boolean> requestPasswordReset(@RequestParam("email") String email) {
        log.debug("REST: UserController.requestPasswordReset( {} )", email);
        return new Response<>(userService.requestUserPasswordReset(email));
    }

    @PostMapping(PASSWORD_RESET_URL)
    public Response<Boolean> finishPasswordReset(@RequestParam("key") String key,
                                                 @RequestBody UserResetPasswordDto userResetPasswordDto) {
        log.debug("REST: UserController.requestPasswordReset( {} )", key);
        return new Response<>(userService.completeUserPasswordReset(key, userResetPasswordDto));
    }

    @PostMapping("/changePassword")
    public void changePassword(@RequestBody Map<String, String> payload, HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        final String sessionId = session.getAttribute(Constants.SESSION_ID_ATTR).toString();
        User user = userSessionService.getUserBySessionId(sessionId);
        userService.changeUserPassword(user, payload);
    }
}