malinink / easy-tests

import easytests.common.controllers.AbstractPersonalController;

import easytests.common.exceptions.ForbiddenException;

import easytests.common.exceptions.NotFoundException;

import easytests.core.models.*;

import easytests.core.options.*;

import easytests.core.services.*;

import easytests.personal.dto.IssueStandardDto;

import easytests.personal.validators.IssueStandardDtoValidator;

import java.util.ArrayList;

import java.util.List;

import java.util.stream.Collectors;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.validation.BindingResult;

import org.springframework.web.bind.annotation.*;

/**

 * @author SingularityA

 */

@Controller

@RequestMapping("personal/issue_standard/")

@SuppressWarnings({

        "checkstyle:MultipleStringLiterals",

        "checkstyle:ClassDataAbstractionCoupling",

        "checkstyle:ClassFanOutComplexity"})

public class IssueStandardsController extends AbstractPersonalController {

    @Autowired

    private IssueStandardsService issueStandardsService;

    @Autowired

    private IssueStandardTopicPrioritiesService topicPrioritiesService;

    @Autowired

    private IssueStandardQuestionTypeOptionsService questionTypeOptionsService;

    @Autowired

    private SubjectsService subjectsService;

    @Autowired

    private QuestionTypesService questionTypesService;

    @Autowired

    private IssueStandardDtoValidator issueStandardValidator;

    @ModelAttribute("questionTypes")

    private List<QuestionTypeModelInterface> getQuestionTypes() {

        return this.questionTypesService.findAll();

    }

    @ModelAttribute("viewUrl")

    private String viewUrl(@PathVariable Integer issueStandardId) {

        return "/personal/issue_standard/" + Integer.toString(issueStandardId) + "/";

    }

    @ModelAttribute("editUrl")

    private String editUrl(@PathVariable Integer issueStandardId) {

        return "/personal/issue_standard/update/" + Integer.toString(issueStandardId) + "/";

    }

    @GetMapping("{issueStandardId}/")

    public String view(Model model,

                       @PathVariable Integer issueStandardId) {

        final IssueStandardModelInterface issueStandard = this.getIssueStandardModel(

                issueStandardId,

                getIssueStandardsOptions());

        model.addAttribute("issueStandard", issueStandard);

        return "issue_standards/view";

    }

    @GetMapping("update/{issueStandardId}/")

    public String update(Model model,

                         @PathVariable Integer issueStandardId) {

        final IssueStandardModelInterface issueStandard = this.getIssueStandardModel(

                issueStandardId,

                getIssueStandardsOptions());

        final IssueStandardDto issueStandardDto = new IssueStandardDto();

        issueStandardDto.map(issueStandard);

        model.addAttribute("issueStandard", issueStandardDto);

        model.addAttribute("subject", issueStandard.getSubject());

        return "issue_standards/edit";

    }

    private IssueStandardModelInterface getIssueStandardModel(

            Integer issueStandardId,

            IssueStandardsOptionsInterface issueStandardsOptions) {

        final IssueStandardModelInterface issueStandardModel = this.issueStandardsService.find(

                issueStandardId,

                issueStandardsOptions);

        if (issueStandardModel == null) {

            throw new NotFoundException();

        }

        final SubjectModelInterface subjectModel = this.getSubjectModel(issueStandardModel.getSubject().getId());

        issueStandardModel.setSubject(subjectModel);

        return issueStandardModel;

    }

    private IssueStandardsOptionsInterface getIssueStandardsOptions() {

        return new IssueStandardsOptions()

                .withTopicPriorities(new IssueStandardTopicPrioritiesOptions())

                .withQuestionTypeOptions(new IssueStandardQuestionTypeOptionsOptions());

    }

    private SubjectModelInterface getSubjectModel(Integer subjectId) {

        final SubjectModelInterface subjectModel = this.subjectsService.find(

                subjectId,

                new SubjectsOptions()

                        .withTopics(new TopicsOptions()));

        if (subjectModel == null) {

            throw new NotFoundException();

        }

        if (!subjectModel.getUser().getId().equals(this.getCurrentUserModel().getId())) {

            throw new ForbiddenException();

        }

        return subjectModel;

    }

    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)

        final IssueStandardModelInterface currentIssueStandardModel

                = this.getIssueStandardModel(newIssueStandardModel.getId(), getIssueStandardsOptions());

        System.out.println(currentIssueStandardModel);

        final List<Integer> newTopicPriorityIds

                = new ArrayList<>(newIssueStandardModel.getTopicPriorities().size());

        newTopicPriorityIds.addAll(newIssueStandardModel.getTopicPriorities().stream()

                .map(IdentityInterface::getId).collect(Collectors.toList()));

        final List<Integer> newQuestionTypeOptionIds

                = new ArrayList<>(newIssueStandardModel.getQuestionTypeOptions().size());

        newQuestionTypeOptionIds.addAll(newIssueStandardModel.getQuestionTypeOptions().stream()

                .map(IdentityInterface::getId).collect(Collectors.toList()));

        for (IssueStandardTopicPriorityModelInterface currentTopicPriority

                : currentIssueStandardModel.getTopicPriorities()) {

            if (!newTopicPriorityIds.contains(currentTopicPriority.getId())) {

                this.topicPrioritiesService.delete(currentTopicPriority);

            }

        }

        for (IssueStandardQuestionTypeOptionModelInterface currentQuestionTypeOption

                : currentIssueStandardModel.getQuestionTypeOptions()) {

            if (!newQuestionTypeOptionIds.contains(currentQuestionTypeOption.getId())) {

                this.questionTypeOptionsService.delete(currentQuestionTypeOption);

            }

        }

        this.issueStandardsService.save(newIssueStandardModel, getIssueStandardsOptions());

    }

}