backend/restservice/src/main/java/com/plannaplan/controllers/CommisionController.java

package com.plannaplan.controllers;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.PathVariable;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;

import java.util.List;
import java.util.Optional;

import com.plannaplan.App;
import com.plannaplan.entities.Assignment;
import com.plannaplan.entities.Commision;
import com.plannaplan.entities.Groups;
import com.plannaplan.entities.User;
import com.plannaplan.exceptions.UserNotFoundException;
import com.plannaplan.responses.mappers.CommisionResponseMappers;
import com.plannaplan.responses.models.CommisionResponse;
import com.plannaplan.services.AssignmentService;
import com.plannaplan.services.CommisionService;
import com.plannaplan.services.GroupService;
import com.plannaplan.types.UserRoles;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
@CrossOrigin
@RequestMapping("/api/" + App.API_VERSION + "/commisions")
@Api(tags = { "Commisions" }, value = "Commisions", description = "Commision is representation of student selected assignments at time. All assignments are attached to some commision so we can see current assignments and also browse histroy of changes for given user")
public class CommisionController extends TokenBasedController {

        @Autowired
        private CommisionService commisionService;

        @Autowired
        private GroupService groupServcicxe;

        @Autowired
        private AssignmentService assignmentService;

        public CommisionController() {
        }

        @PostMapping(value = { "/user", "/user/{id}" })
        @ApiOperation(value = "Create commision with assignents to given groups. If group doesn't exist error will be thrown")
        public ResponseEntity<String> addCommision(
                        @RequestBody @ApiParam(value = "List of groups ids user want to assign to. If group doesnt exisit error will be thrown") List<Long> groups,
                        @PathVariable(name = "id", required = false) Long userId) {

                try {

                        final User asker = this.getCurrentUser()
                                        .orElseThrow(() -> new UserNotFoundException("Invalid token"));

                        final User user = userId != null
                                        ? userService.getById(userId).orElseThrow(
                                                        () -> new UserNotFoundException("Given user id not exist"))
                                        : asker;

                        Assert.isTrue((asker.getRole() == UserRoles.DEANERY && user.getRole() == UserRoles.STUDENT
                                        || (asker.getId().equals(user.getId()) && user.getRole() == UserRoles.STUDENT)),
                                        "Incorrect attempt to change plan");

                        Optional<Long> notExistingGroup = this.groupServcicxe.findNotExistingGroup(groups);
                        Assert.isTrue(!notExistingGroup.isPresent(), "Group "
                                        + notExistingGroup.orElse(Long.MIN_VALUE).toString() + "doesn't exist");

                        final Commision com = new Commision(user);
                        this.commisionService.save(com);

                        groups.stream().forEach((groupId) -> {
                                Groups group = this.groupServcicxe.getGroupById(groupId)
                                                .orElseThrow(() -> new NullPointerException());
                                Assignment a = new Assignment(group, com);
                                this.assignmentService.save(a);
                        });

                        return new ResponseEntity<>("Succes", HttpStatus.OK);
                } catch (UserNotFoundException exception) {
                        return new ResponseEntity<>(exception.getMessage(), HttpStatus.NOT_FOUND);
                } catch (IllegalArgumentException exception) {
                        return new ResponseEntity<>(exception.getMessage(), HttpStatus.BAD_REQUEST);
                }
        }

        @GetMapping("/user")
        @ApiOperation("Return list of user all commisions (history of schedules)")
        public ResponseEntity<List<CommisionResponse>> getAlCommisions() throws UserNotFoundException {
                User user = this.getCurrentUser().orElseThrow(() -> new NullPointerException());
                List<CommisionResponse> result = CommisionResponseMappers
                                .mapToResponse(this.commisionService.getUsersCommisions(user));
                return new ResponseEntity<>(result, HttpStatus.OK);
        }

        @PreAuthorize("hasRole('ROLE_DEANERY')")
        @GetMapping("/user/{id}")
        @ApiOperation("Return list of commisions for given user. To be able to access this data u need to provide DEANERY token")
        public ResponseEntity<List<CommisionResponse>> getCommision(@PathVariable(name = "id") Long userId)
                        throws UserNotFoundException {
                User user = this.userService.getById(userId).orElseThrow(() -> new NullPointerException());
                List<CommisionResponse> result = CommisionResponseMappers
                                .mapToResponse(this.commisionService.getUsersCommisions(user));
                return new ResponseEntity<>(result, HttpStatus.OK);
        }

}