backend/src/main/java/nju/seec/helper/service/impl/QuizServiceImpl.java

package nju.seec.helper.service.impl;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import nju.seec.helper.aspect.auth.LoginUser;
import nju.seec.helper.aspect.message.Message;
import nju.seec.helper.dao.*;
import nju.seec.helper.dto.quiz.QuizDTO;
import nju.seec.helper.entity.Quiz;
import nju.seec.helper.entity.Slide;
import nju.seec.helper.enums.*;
import nju.seec.helper.exception.HelperException;
import nju.seec.helper.service.QuizService;
import nju.seec.helper.vo.quiz.QuizVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;
import java.util.Set;


/**
 * @author xst
 * <p>
 * updated by cst
 */
@Service
public class QuizServiceImpl implements QuizService {
    private final SlideDAO slideDAO;
    private final QuizDAO quizDAO;
    private final QuizStudentAnswerDAO quizStudentAnswerDAO;
    private final ChooseDAO chooseDAO;
    private final UserDAO userDAO;

    @Autowired
    public QuizServiceImpl(SlideDAO slideDAO, QuizDAO quizDAO, QuizStudentAnswerDAO quizStudentAnswerDAO, ChooseDAO chooseDAO, UserDAO userDAO) {
        this.slideDAO = slideDAO;
        this.quizDAO = quizDAO;
        this.quizStudentAnswerDAO = quizStudentAnswerDAO;
        this.chooseDAO = chooseDAO;
        this.userDAO = userDAO;
    }

    private static final Map<SlideState, Map<QuizType, QuizState>> MAP = ImmutableMap.of(
            SlideState.DRAFT, ImmutableMap.of(
                    QuizType.BEFORE_CLASS, QuizState.NOT_STARTED,
                    QuizType.IN_CLASS, QuizState.NOT_STARTED,
                    QuizType.AFTER_CLASS, QuizState.NOT_STARTED
            ),
            SlideState.BEFORE_CLASS, ImmutableMap.of(
                    QuizType.BEFORE_CLASS, QuizState.ONGOING,
                    QuizType.IN_CLASS, QuizState.NOT_STARTED,
                    QuizType.AFTER_CLASS, QuizState.NOT_STARTED
            ),
            SlideState.IN_CLASS, ImmutableMap.of(
                    QuizType.BEFORE_CLASS, QuizState.CLOSED,
                    QuizType.IN_CLASS, QuizState.ONGOING,
                    QuizType.AFTER_CLASS, QuizState.NOT_STARTED
            ),
            SlideState.AFTER_CLASS, ImmutableMap.of(
                    QuizType.BEFORE_CLASS, QuizState.CLOSED,
                    QuizType.IN_CLASS, QuizState.CLOSED,
                    QuizType.AFTER_CLASS, QuizState.ONGOING
            ),
            SlideState.FINISH, ImmutableMap.of(
                    QuizType.BEFORE_CLASS, QuizState.CLOSED,
                    QuizType.IN_CLASS, QuizState.CLOSED,
                    QuizType.AFTER_CLASS, QuizState.CLOSED
            )
    );

    @Message(MessageType.QUIZ_NEW)
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QuizVO createQuiz(LoginUser user, QuizDTO quizDTO) {
        Slide slide = slideDAO.findSlideById(quizDTO.getSlideId());

        Quiz quiz = new Quiz()
                .setCourse(slide.getCourse())
                .setSlide(slide)
                .setTeacher(slide.getTeacher())
                .setType(quizDTO.getType())
                .setState(MAP.get(slide.getState()).get(quizDTO.getType()))
                .setName(quizDTO.getName())
                .setMaxSubmitNumber(quizDTO.getMaxSubmitTime())
                .setQuestions(quizDTO.getQuestions());

        if (!existsAddAuth(user, quiz)) {
            throw HelperException.of(ExceptionType.FORBIDDEN, "您无权创建该测试");
        }

        try {
            quiz = quizDAO.save(quiz);
            return new QuizVO(quiz);
        } catch (DataIntegrityViolationException e) {
            throw HelperException.of(ExceptionType.CONFLICT, "创建失败，请检查测试信息是否正确且不与已有测试冲突");
        }
    }

    @Message(MessageType.QUIZ_NEW)
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QuizVO modifyQuiz(LoginUser user, Long quizId, QuizDTO quizDTO) {
        Quiz quiz = quizDAO.findQuizById(quizId);

        if (existsUpdateAuth(user, quiz)) {
            throw HelperException.of(ExceptionType.FORBIDDEN, "您无权修改该测试");
        }

        if (quizStudentAnswerDAO.existsByQuiz(quiz)) {
            throw HelperException.of(ExceptionType.FORBIDDEN, "该测试已有提交，无法修改");
        }

        try {
            quiz = quizDAO.save(quiz
                    .setType(quizDTO.getType())
                    .setState(MAP.get(quiz.getSlide().getState()).get(quizDTO.getType()))
                    .setName(quizDTO.getName())
                    .setMaxSubmitNumber(quizDTO.getMaxSubmitTime())
                    .setQuestions(quizDTO.getQuestions()));
            return new QuizVO(quiz);
        } catch (DataIntegrityViolationException e) {
            throw HelperException.of(ExceptionType.CONFLICT, "修改失败，请检查测试信息是否正确且不与已有测试冲突");
        }
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void deleteQuiz(LoginUser user, Long quizId) {
        Quiz quiz = quizDAO.findQuizById(quizId);
        if (!existsDelAuth(user, quiz)) {
            throw HelperException.of(ExceptionType.FORBIDDEN, "您无权删除该测试");
        }
        quiz.setDeleteAt(System.currentTimeMillis());
        quizDAO.save(quiz);
    }

    private static final Set<QuizState> STATES_NOT_GET_BY_STUDENT_SET = ImmutableSet.of(QuizState.NOT_STARTED);

    @Transactional(readOnly = true)
    @Override
    public Page<QuizVO> teacherGetQuizzesBySlide(LoginUser user, Long slideId, String key, Pageable pageable) {
        return quizDAO.findBySlideAndNameContains(slideDAO.findSlideById(slideId), key, pageable).map(QuizVO::new);
    }

    @Transactional(readOnly = true)
    @Override
    public Page<QuizVO> studentGetQuizzesBySlide(LoginUser user, Long slideId, String key, Pageable pageable) {
        return quizDAO.findBySlideAndStateNotInAndNameContains(slideDAO.findSlideById(slideId), STATES_NOT_GET_BY_STUDENT_SET, key, pageable).map(QuizVO::new);
    }

    @Transactional(readOnly = true)
    @Override
    public Page<QuizVO> teacherGetQuizzesByState(LoginUser user, QuizState state, String key, Pageable pageable) {
        return quizDAO.findByTeacherAndStateAndNameContains(userDAO.findUserById(user.getId()), state, key, pageable).map(QuizVO::new);
    }

    @Transactional(readOnly = true)
    @Override
    public Page<QuizVO> studentGetQuizzesByState(LoginUser user, QuizState state, String key, Pageable pageable) {
        if (STATES_NOT_GET_BY_STUDENT_SET.contains(state)) {
            throw HelperException.of(ExceptionType.FORBIDDEN, "您暂时无法获取该状态的测试");
        }
        Set<Long> courseIds = chooseDAO.findCourseIdsByStudentId(user.getId());
        return quizDAO.findByCourseIdInAndStateAndNameContains(courseIds, state, key, pageable).map(QuizVO::new);
    }

    @Transactional(readOnly = true)
    @Override
    public QuizVO getOneQuiz(LoginUser user, Long quizId) {
        Quiz quiz = quizDAO.findQuizById(quizId);
        if (!existsGetAuth(user, quiz)) {
            throw HelperException.of(ExceptionType.FORBIDDEN, "您无权查看该测试");
        }
        return new QuizVO(quiz);
    }

    @Message(MessageType.QUIZ_NEW)
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void modifyQuizState(Slide slide) {
        List<Quiz> quizzes = quizDAO.findBySlide(slide);
        quizzes.forEach(quiz -> quiz.setState(MAP.get(slide.getState()).get(quiz.getType())));
    }

    @Override
    public boolean existsAddAuth(LoginUser user, Quiz quiz) {
        return quiz.getCourse().getTeacher().getId().equals(user.getId());
    }

    @Override
    public boolean existsDelAuth(LoginUser user, Quiz quiz) {
        return quiz.getTeacher().getId().equals(user.getId());
    }

    @Override
    public boolean existsUpdateAuth(LoginUser user, Quiz quiz) {
        return quiz.getTeacher().getId().equals(user.getId());
    }

    @Override
    public boolean existsGetAuth(LoginUser user, Quiz quiz) {
        return user.getRole() == UserRole.TEACHER
                || !STATES_NOT_GET_BY_STUDENT_SET.contains(quiz.getState());
    }
}