blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
luohairen
2024-11-14 247cb86585a1d1894596ed18a6c93efecb992946 
 src/main/java/com/ycl/jxkg/controller/student/DashboardController.java


@@ -1,19 +1,20 @@


package com.ycl.jxkg.controller.student;




import com.ycl.jxkg.base.BaseApiController;


import com.ycl.jxkg.base.RestResponse;


import com.ycl.jxkg.domain.TaskExam;


import com.ycl.jxkg.domain.TaskExamCustomerAnswer;


import com.ycl.jxkg.domain.TextContent;


import com.ycl.jxkg.domain.User;


import com.ycl.jxkg.domain.enums.ExamPaperTypeEnum;


import com.ycl.jxkg.base.Result;


import com.ycl.jxkg.domain.entity.TaskExam;


import com.ycl.jxkg.domain.entity.TaskExamCustomerAnswer;


import com.ycl.jxkg.domain.entity.TextContent;


import com.ycl.jxkg.domain.entity.User;


import com.ycl.jxkg.enums.ExamPaperTypeEnum;


import com.ycl.jxkg.domain.task.TaskItemAnswerObject;


import com.ycl.jxkg.domain.task.TaskItemObject;


import com.ycl.jxkg.service.*;


import com.ycl.jxkg.utility.DateTimeUtil;


import com.ycl.jxkg.utility.JsonUtil;


import com.ycl.jxkg.viewmodel.student.dashboard.*;


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


import com.ycl.jxkg.utils.DateTimeUtil;


import com.ycl.jxkg.utils.JsonUtil;


import com.ycl.jxkg.domain.vo.student.dashboard.*;


import lombok.RequiredArgsConstructor;


import org.springframework.beans.BeanUtils;


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


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


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


@@ -23,6 +24,7 @@


import java.util.List;


import java.util.stream.Collectors;




@RequiredArgsConstructor


@RestController("StudentDashboardController")


@RequestMapping(value = "/api/student/dashboard")


public class DashboardController extends BaseApiController {


@@ -34,80 +36,71 @@


    private final TaskExamCustomerAnswerService taskExamCustomerAnswerService;


    private final TextContentService textContentService;




    @Autowired


    public DashboardController(UserService userService, ExamPaperService examPaperService, QuestionService questionService, TaskExamService taskExamService, TaskExamCustomerAnswerService taskExamCustomerAnswerService, TextContentService textContentService) {


        this.userService = userService;


        this.examPaperService = examPaperService;


        this.questionService = questionService;


        this.taskExamService = taskExamService;


        this.taskExamCustomerAnswerService = taskExamCustomerAnswerService;


        this.textContentService = textContentService;


    }




    @RequestMapping(value = "/index", method = RequestMethod.POST)


    public RestResponse<IndexVM> index() {


        IndexVM indexVM = new IndexVM();


    public Result<IndexVO> index() {


        IndexVO indexVO = new IndexVO();


        User user = getCurrentUser();




        PaperFilter fixedPaperFilter = new PaperFilter();


        fixedPaperFilter.setGradeLevel(user.getUserLevel());


        fixedPaperFilter.setExamPaperType(ExamPaperTypeEnum.Fixed.getCode());


        indexVM.setFixedPaper(examPaperService.indexPaper(fixedPaperFilter));


        indexVO.setFixedPaper(examPaperService.indexPaper(fixedPaperFilter));




        PaperFilter timeLimitPaperFilter = new PaperFilter();


        timeLimitPaperFilter.setDateTime(new Date());


        timeLimitPaperFilter.setGradeLevel(user.getUserLevel());


        timeLimitPaperFilter.setExamPaperType(ExamPaperTypeEnum.TimeLimit.getCode());


        timeLimitPaperFilter.setExamPaperType(ExamPaperTypeEnum.Random.getCode());




        List<PaperInfo> limitPaper = examPaperService.indexPaper(timeLimitPaperFilter);


        List<PaperInfoVM> paperInfoVMS = limitPaper.stream().map(d -> {


            PaperInfoVM vm = modelMapper.map(d, PaperInfoVM.class);


            vm.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime()));


            vm.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime()));


            return vm;


        List<PaperInfoVO> paperInfoVOS = limitPaper.stream().map(d -> {


            PaperInfoVO vo = new PaperInfoVO();


            BeanUtils.copyProperties(d, vo);


            vo.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime()));


            vo.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime()));


            return vo;


        }).collect(Collectors.toList());


        indexVM.setTimeLimitPaper(paperInfoVMS);


        return RestResponse.ok(indexVM);


        indexVO.setTimeLimitPaper(paperInfoVOS);


        return Result.ok(indexVO);


    }






    @RequestMapping(value = "/task", method = RequestMethod.POST)


    public RestResponse<List<TaskItemVm>> task() {


    public Result<List<TaskItemVO>> task() {


        User user = getCurrentUser();


        List<TaskExam> taskExams = taskExamService.getByGradeLevel(user.getUserLevel());


        if (taskExams.size() == 0) {


            return RestResponse.ok(new ArrayList<>());


            return Result.ok(new ArrayList<>());


        }


        List<Integer> tIds = taskExams.stream().map(taskExam -> taskExam.getId()).collect(Collectors.toList());


        List<TaskExamCustomerAnswer> taskExamCustomerAnswers = taskExamCustomerAnswerService.selectByTUid(tIds, user.getId());


        List<TaskItemVm> vm = taskExams.stream().map(t -> {


            TaskItemVm itemVm = new TaskItemVm();


        List<TaskItemVO> vm = taskExams.stream().map(t -> {


            TaskItemVO itemVm = new TaskItemVO();


            itemVm.setId(t.getId());


            itemVm.setTitle(t.getTitle());


            TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswers.stream()


                    .filter(tc -> tc.getTaskExamId().equals(t.getId())).findFirst().orElse(null);


            List<TaskItemPaperVm> paperItemVMS = getTaskItemPaperVm(t.getFrameTextContentId(), taskExamCustomerAnswer);


            List<TaskItemPaperVO> paperItemVMS = getTaskItemPaperVm(t.getFrameTextContentId(), taskExamCustomerAnswer);


            itemVm.setPaperItems(paperItemVMS);


            return itemVm;


        }).collect(Collectors.toList());


        return RestResponse.ok(vm);


        return Result.ok(vm);


    }






    private List<TaskItemPaperVm> getTaskItemPaperVm(Integer tFrameId, TaskExamCustomerAnswer taskExamCustomerAnswers) {


        TextContent textContent = textContentService.selectById(tFrameId);


    private List<TaskItemPaperVO> getTaskItemPaperVm(Integer tFrameId, TaskExamCustomerAnswer taskExamCustomerAnswers) {


        TextContent textContent = textContentService.getById(tFrameId);


        List<TaskItemObject> paperItems = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class);




        List<TaskItemAnswerObject> answerPaperItems = null;


        if (null != taskExamCustomerAnswers) {


            TextContent answerTextContent = textContentService.selectById(taskExamCustomerAnswers.getTextContentId());


            TextContent answerTextContent = textContentService.getById(taskExamCustomerAnswers.getTextContentId());


            answerPaperItems = JsonUtil.toJsonListObject(answerTextContent.getContent(), TaskItemAnswerObject.class);


        }






        List<TaskItemAnswerObject> finalAnswerPaperItems = answerPaperItems;


        return paperItems.stream().map(p -> {


                    TaskItemPaperVm ivm = new TaskItemPaperVm();


                    TaskItemPaperVO ivm = new TaskItemPaperVO();


                    ivm.setExamPaperId(p.getExamPaperId());


                    ivm.setExamPaperName(p.getExamPaperName());


                    if (null != finalAnswerPaperItems) {