malinink / easy-tests

import easytests.common.controllers.AbstractCrudController;

import easytests.core.models.*;

import easytests.core.options.AnswersOptions;

import easytests.core.options.AnswersOptionsInterface;

import easytests.core.options.QuestionsOptionsInterface;

import easytests.core.options.builder.AnswersOptionsBuilder;

import easytests.core.options.builder.QuestionsOptionsBuilder;

import easytests.core.services.AnswersService;

import easytests.core.services.QuestionTypesService;

import easytests.core.services.QuestionsService;

import easytests.personal.dto.AnswerDto;

import easytests.personal.dto.AnswerListDto;

import easytests.personal.validators.AnswerDtoValidator;

import java.util.*;

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 rezenbekk

 */

@Controller

@SuppressWarnings("checkstyle:MultipleStringLiterals")

@RequestMapping("/personal/topics/{topicId}/questions/{questionId}/update_answers/")

public class AnswersController extends AbstractCrudController {

    @Autowired

    private QuestionsService questionsService;

    @Autowired

    private QuestionsOptionsBuilder questionsOptionsBuilder;

    @Autowired

    private QuestionTypesService questionTypesService;

    @Autowired

    private AnswersOptionsBuilder answersOptionsBuilder;

    @Autowired

    private AnswersService answersService;

    @Autowired

    private AnswerDtoValidator answerDtoValidator;

    @GetMapping("")

    public String update(

            Model model,

            @PathVariable("questionId") Integer questionId,

            @PathVariable("topicId") Integer topicId) {

        final QuestionModelInterface questionModel = getQuestionModel(questionId, false);

        injectQuestionTypeModels(model);

        final AnswerListDto answerDtoList = new AnswerListDto();

        answerDtoList.map(questionModel);

        setUpdateBehaviour(model);

        model.addAttribute("questionId", questionId);

        model.addAttribute("question", questionModel);

        model.addAttribute("answerDtoList", answerDtoList);

        //model.addAttribute("oldDtoList", answerDtoList);

        model.addAttribute("topicId", topicId);

        return "answers/form";

    }

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

                                   List<AnswerModelInterface> oldAnswers) {

        final List<Integer> newAnswersIds = new ArrayList<>(newAnswers.size());

        newAnswersIds.addAll(newAnswers.stream().map(AnswerDto::getId)

                .collect(Collectors.toList()));

        for (AnswerModelInterface oldAnswer : oldAnswers) {

            if (!newAnswersIds.contains(oldAnswer.getId())) {

                System.out.println("DELETION: " + oldAnswer);

                this.answersService.delete(oldAnswer);

            }

        }

    }

    private QuestionModelInterface getQuestionModel(Integer id, Boolean forDelete) {

        final QuestionsOptionsInterface questionsOptions = this.questionsOptionsBuilder

                .forAuth()

                .withAnswers(new AnswersOptions());

        final QuestionModelInterface questionModel = this.questionsService.find(id, questionsOptions);

        //checkModel(questionModel, topicId);

        if (forDelete) {

            return this.questionsService.find(id, this.questionsOptionsBuilder.forDelete());

        }

        return questionModel;

    }

    private void injectQuestionTypeModels(Model model) {

        final List<QuestionTypeModelInterface> questionTypes = this.questionTypesService.findAll();

        model.addAttribute("questionTypes", questionTypes);

    }

        final AnswersOptionsInterface answersOptions = this.answersOptionsBuilder.forAuth();

        final List<AnswerModelInterface> answersList = answersService.findByQuestion(questionModel, answersOptions);

        return answersList;

    }

}