sourcecode/server/gateway-api/src/main/java/com/qxgmat/controller/api/SentenceController.java

package com.qxgmat.controller.api;

import com.alibaba.fastjson.JSONObject;
import com.nuliji.tools.Response;
import com.nuliji.tools.ResponseHelp;
import com.nuliji.tools.Transform;
import com.nuliji.tools.exception.AuthException;
import com.qxgmat.data.constants.enums.SettingKey;
import com.qxgmat.data.constants.enums.logic.SentenceLogic;
import com.qxgmat.data.constants.enums.module.PaperOrigin;
import com.qxgmat.data.dao.entity.*;
import com.qxgmat.dto.extend.CommentExtendDto;
import com.qxgmat.dto.extend.UserPaperBaseExtendDto;
import com.qxgmat.dto.extend.UserReportExtendDto;
import com.qxgmat.dto.request.*;
import com.qxgmat.dto.response.*;
import com.qxgmat.help.ShiroHelp;
import com.qxgmat.service.UserPaperService;
import com.qxgmat.service.extend.SentenceService;
import com.qxgmat.service.inline.SentencePaperService;
import com.qxgmat.service.UserCollectQuestionService;
import com.qxgmat.service.UsersService;
import com.qxgmat.service.extend.QuestionFlowService;
import com.qxgmat.service.inline.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpSession;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/sentence")
@Api(tags = "长难句", description = "长难句接口")
public class SentenceController
{
    @Autowired
    private ShiroHelp shiroHelp;

    @Autowired
    private SentenceArticleService sentenceArticleService;

    @Autowired
    private SentenceQuestionService sentenceQuestionService;

    @Autowired
    private SentencePaperService sentencePaperService;

    @Autowired
    private SentenceCodeService sentenceCodeService;

    @Autowired
    private SentenceService sentenceService;

    @Autowired
    private QuestionService questionService;

    @Autowired
    private QuestionNoService questionNoService;

    @Autowired
    private SettingService settingService;

    @Autowired
    private CourseDataService courseDataService;

    @Autowired
    private CommentService commentService;

    @Autowired
    private UsersService usersService;

    @Autowired
    private UserPaperService userPaperService;

    @Autowired
    private UserReportService userReportService;

    @Autowired
    private UserSentenceProgressService userSentenceProgressService;

    @Autowired
    private UserSentenceRecordService userSentenceRecordService;

    @Autowired
    private UserCollectQuestionService userCollectQuestionService;

    @Autowired
    private QuestionFlowService questionFlowService;

    @RequestMapping(value = "/info", method = RequestMethod.GET)
    @ApiOperation(value = "所有长难句信息", httpMethod = "GET")
    public Response<UserSentenceInfoDto> info(HttpSession session) {
        UserSentenceInfoDto dto = new UserSentenceInfoDto();

        User user = (User) shiroHelp.getLoginUser();
        if (user != null){
            // 用户code状态
            SentenceCode code = sentenceCodeService.isActive(user.getId());
            if (code != null){
                dto.setCode(code.getCode());
            }
        }

        // 章节信息
        Setting entity = settingService.getByKey(SettingKey.SENTENCE);
        JSONObject value = entity.getValue();
        dto.setChapters(value.getJSONArray("chapters"));
        dto.setTrailPages(value.getInteger("trailPages"));

        // 评论： 通过资料的长难句分类获取该资料的评论
        CourseData courseData = courseDataService.getSentence();
        if(courseData != null){
            List<Comment> commentList = commentService.list(1, 1, "course_data", courseData.getId().toString());
            dto.setComments(Transform.convert(commentList, CommentExtendDto.class));
        }
        
        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/active", method = RequestMethod.PUT)
    @ApiOperation(value = "激活长难句", httpMethod = "PUT")
    public Response<Boolean> active(@RequestBody @Validated UserSentenceCodeDto dto) {
        User user = (User) shiroHelp.getLoginUser();
        if (user == null) throw new AuthException("需要登录");
        sentenceService.active(user.getId(), dto.getCode());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/article/list", method = RequestMethod.GET)
    @ApiOperation(value = "长难句文章列表", httpMethod = "GET")
    public Response<List<UserSentenceArticleDto>> listArticle(
            HttpSession session) {
        User user = (User) shiroHelp.getLoginUser();

        List<SentenceArticle> p = sentenceArticleService.all();
        List<UserSentenceArticleDto> pr = Transform.convert(p, UserSentenceArticleDto.class);

        if (user != null){
            // 查询文章进度
            List<UserSentenceProgress> progressList = userSentenceProgressService.all(user.getId());

            Map<String, UserSentenceProgress> progressMap = new HashMap<>();
            for (UserSentenceProgress progress:progressList){
                progressMap.put(String.format("%d-%d", progress.getChapter(), progress.getPart()), progress);
            }
            for (UserSentenceArticleDto dto : pr){
                UserSentenceProgress progress = progressMap.get(String.format("%d-%d", dto.getChapter(), dto.getPart()));
                dto.setProgress(progress == null ? 0 : progress.getProgress());
                dto.setTimes(progress == null ? 0:progress.getTimes());
            }
        }
        return ResponseHelp.success(pr);
    }

    @RequestMapping(value = "/article/detail", method = RequestMethod.GET)
    @ApiOperation(value = "长难句文章详情", httpMethod = "GET")
    public Response<UserSentenceArticleDetailDto> detailArticle(
            @RequestParam(required = true) Integer articleId
    ) {
        User user = (User) shiroHelp.getLoginUser();

        SentenceArticle article = sentenceArticleService.get(articleId);
        UserSentenceArticleDetailDto dto = Transform.convert(article, UserSentenceArticleDetailDto.class);

        if (user != null){
            // 查询文章进度
            UserSentenceProgress progress = userSentenceProgressService.get(user.getId(), article.getChapter(), article.getPart());
            if (progress != null){
                dto.setProgress(progress.getProgress());
                dto.setTimes(progress.getTimes());
            }
        }

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/article/progress", method = RequestMethod.PUT)
    @ApiOperation(value = "更新长难句文章进度", httpMethod = "PUT")
    public Response<Boolean> articleProcess(@RequestBody @Validated UserSentenceProgressDto dto) {
        UserSentenceProgress entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        if (user == null) throw new AuthException("需要登录");

        // 添加阅读记录
        if (dto.getCurrentChapter() != null && dto.getCurrentPart() != null && dto.getTime() != null && dto.getTime() > 0){
            userSentenceRecordService.add(UserSentenceRecord.builder()
                    .userId(user.getId())
                    .chapter(dto.getCurrentChapter())
                    .part(dto.getCurrentPart())
                    .userTime(dto.getTime())
                    .build());
        }

        // 获取本章节的最大part数
//        Integer max = sentenceArticleService.maxPart(dto.getChapter());

        // 更新阅读进度
        userSentenceProgressService.updateProgress(user.getId(), dto.getChapter(), dto.getPart(), dto.getProgress());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/paper/list", method = RequestMethod.GET)
    @ApiOperation(value = "长难句组卷列表", httpMethod = "GET")
    public Response<List<UserSentencePaperDto>> listPaper(
            HttpSession session) {
        User user = (User) shiroHelp.getLoginUser();
        List<SentencePaper> p;
        // 查询用户code
        if (user != null && sentenceCodeService.isActive(user.getId()) != null){
            p = sentencePaperService.listByLogic(SentenceLogic.NO);
        } else {
            p = sentencePaperService.listByLogic(SentenceLogic.TRAIL);
        }
        List<UserSentencePaperDto> pr = Transform.convert(p, UserSentencePaperDto.class);

        // 获取试卷统计信息
        Map<Integer, Integer[]> questionNoIdsMap = new HashMap<>();
        for(SentencePaper paper : p){
            questionNoIdsMap.put(paper.getId(), paper.getQuestionNoIds());
        }
        Map statMap = questionNoService.statPaperMap(questionNoIdsMap);
        Transform.combine(pr, statMap, UserSentencePaperDto.class, "id", "stat");

        if (user != null){
            // 获取做题记录
            Collection ids = Transform.getIds(p, SentencePaper.class, "id");
            List<UserPaper> userPaperList = userPaperService.listWithOrigin(user.getId(), PaperOrigin.SENTENCE, ids, null);
            Transform.combine(pr, userPaperList, UserSentencePaperDto.class, "id", "paper", UserPaper.class, "originId", UserPaperBaseExtendDto.class);
            // 绑定userPaperId，用于关联report
            Map userPaperMap = Transform.getMap(userPaperList, UserPaper.class, "originId", "id");
            Transform.combine(pr, userPaperMap, UserSentencePaperDto.class, "id", "userPaperId");

            // 获取最后一次作业结果
            Collection paperIds = Transform.getIds(userPaperList, UserPaper.class, "id");
            List<UserReport> reportList = userReportService.listWithLast(paperIds);
            Transform.combine(pr, reportList, UserSentencePaperDto.class, "userPaperId", "report", UserReport.class, "paperId", UserReportExtendDto.class);
        }

        return ResponseHelp.success(pr);
    }

    @RequestMapping(value = "/paper", method = RequestMethod.GET)
    @ApiOperation(value = "获取练习卷", notes = "获取练习卷", httpMethod = "GET")
    public Response<PaperBaseDto> detailPaper(
            @RequestParam(required = true, name="id") Integer paperId
    )  {
        User user = (User) shiroHelp.getLoginUser();
        SentencePaper paper = sentencePaperService.get(paperId);

        PaperBaseDto paperDto = Transform.convert(paper, PaperBaseDto.class);

        return ResponseHelp.success(paperDto);
    }
//
//    @RequestMapping(value = "/report/detail", method = RequestMethod.GET)
//    @ApiOperation(value = "获取详细记录", notes = "获取报告", httpMethod = "GET")
//    public Response<UserReportDetailDto> detailReport(
//            @RequestParam(required = true, name="id") Integer userReportId
//    )  {
//        User user = (User) shiroHelp.getLoginUser();
//        UserReportRelation report = questionFlowService.baseReport(user.getId(), userReportId);
//
//        UserReportDetailDto userReportDto = Transform.convert(report, UserReportDetailDto.class);
//
//        // todo 绑定数据
//
//        return ResponseHelp.success(userReportDto);
//    }
//
//    @RequestMapping(value = "/report/question", method = RequestMethod.GET)
//    @ApiOperation(value = "获取做题记录", notes = "获取报告题目", httpMethod = "GET")
//    public Response<List<UserSentenceQuestionDetailDto>> detailReportQuestion(
//            @RequestParam(required = true, name="id") Integer userReportId
//    )  {
//        User user = (User) shiroHelp.getLoginUser();
//        List<UserQuestion> userQuestionList = questionFlowService.listByReport(user.getId(), userReportId);
//
//        List<UserSentenceQuestionDetailDto> userQuestionDetailDtos = Transform.convert(userQuestionList, UserSentenceQuestionDetailDto.class);
//
//        // todo 绑定数据
//
//        return ResponseHelp.success(userQuestionDetailDtos);
//    }
//
//    @RequestMapping(value = "/start", method = RequestMethod.POST)
//    @ApiOperation(value = "开始做题", notes = "提交考试设置", httpMethod = "POST")
//    public Response<UserReportBaseDto> start(@RequestBody @Validated SentenceStartDto dto)  {
//        User user = (User) shiroHelp.getLoginUser();
//        JSONObject setting = new JSONObject();
//        UserReportRelation report = questionFlowService.start(user.getId(), PaperOrigin.SENTENCE, dto.getPaperId(), setting);
//
//        UserReportBaseDto userReportBaseDto = Transform.convert(report, UserReportBaseDto.class);
//
//        return ResponseHelp.success(userReportBaseDto);
//    }
//
//    @RequestMapping(value = "/continue", method = RequestMethod.POST)
//    @ApiOperation(value = "继续做题", notes = "获取报告信息", httpMethod = "POST")
//    public Response<UserReportBaseDto> continueReport(@RequestBody @Validated ReportContinueDto dto)  {
//        User user = (User) shiroHelp.getLoginUser();
//        UserReportRelation report = questionFlowService.continueReport(user.getId(), dto.getUserReportId());
//
//        UserReportBaseDto userReportBaseDto = Transform.convert(report, UserReportBaseDto.class);
//
//        return ResponseHelp.success(userReportBaseDto);
//    }
//
//    @RequestMapping(value = "/next", method = RequestMethod.POST)
//    @ApiOperation(value = "获取下一题", notes = "获取下一题", httpMethod = "POST")
//    public Response<UserSentenceQuestionBaseDto> next(@RequestBody @Validated ReportNextDto dto)  {
//        User user = (User) shiroHelp.getLoginUser();
//
//        UserQuestion userQuestion = questionFlowService.next(user.getId(), dto.getUserReportId());
//
//        UserSentenceQuestionBaseDto baseDto = Transform.convert(userQuestion, UserSentenceQuestionBaseDto.class);
//
//        // 绑定question
//        baseDto.setQuestion(Transform.convert(questionService.get(userQuestion.getQuestionId()), QuestionExtendDto.class));
//
//        // 绑定sentenceQuestion
//        baseDto.setSentence(Transform.convert(sentenceQuestionService.get(userQuestion.getQuestionNoId()), SentenceQuestionBaseExtendDto.class));
//
//        // 绑定collect
//        baseDto.setCollect(userCollectQuestionService.getByUserAndQuestion(user.getId(), userQuestion.getQuestionId()) != null);
//
//        return ResponseHelp.success(null);
//    }
//
//    @RequestMapping(value = "/submit", method = RequestMethod.POST)
//    @ApiOperation(value = "提交题目答案", notes = "提交题目", httpMethod = "POST")
//    public Response<Boolean> submit(@RequestBody @Validated QuestionSubmitDto dto)  {
//        User user = (User) shiroHelp.getLoginUser();
//        Boolean result = questionFlowService.submit(user.getId(), dto.getUserQuestionId(), dto.getTime(), dto.getAnswer(), dto.getSetting());
//        return ResponseHelp.success(result);
//    }
//
//    @RequestMapping(value = "/finish", method = RequestMethod.POST)
//    @ApiOperation(value = "完成考试", notes = "完成考试", httpMethod = "POST")
//    public Response<Boolean> finish(@RequestBody @Validated ReportFinishDto dto)  {
//        User user = (User) shiroHelp.getLoginUser();
//
//        Boolean result = questionFlowService.finish(user.getId(), dto.getUserReportId());
//        return ResponseHelp.success(result);
//    }
//
//    @RequestMapping(value = "/restart", method = RequestMethod.POST)
//    @ApiOperation(value = "重置考试", notes = "重置考试", httpMethod = "POST")
//    public Response<Boolean> restart(@RequestBody @Validated PaperRestartDto dto)  {
//        User user = (User) shiroHelp.getLoginUser();
//
//        questionFlowService.restart(dto.getUserPaperId(), user.getId());
//
//        return ResponseHelp.success(true);
//    }
}