server/distributed-print/src/main/java/com/qmth/distributed/print/api/ExamTaskApplyController.java

package com.qmth.distributed.print.api;

import com.qmth.boot.api.constant.ApiConstant;
import com.qmth.distributed.print.business.bean.dto.ExamTaskDetailCardDto;
import com.qmth.distributed.print.business.entity.ExamTask;
import com.qmth.distributed.print.business.entity.ExamTaskApplyTemp;
import com.qmth.distributed.print.business.entity.ExamTaskDetail;
import com.qmth.distributed.print.business.entity.TFFlowJoin;
import com.qmth.distributed.print.business.enums.ExamObjectType;
import com.qmth.distributed.print.business.enums.ExamStatusEnum;
import com.qmth.distributed.print.business.service.*;
import com.qmth.teachcloud.common.annotation.OperationLogDetail;
import com.qmth.teachcloud.common.contant.SystemConstant;
import com.qmth.teachcloud.common.entity.SysUser;
import com.qmth.teachcloud.common.enums.ExceptionResultEnum;
import com.qmth.teachcloud.common.enums.log.CustomizedOperationTypeEnum;
import com.qmth.teachcloud.common.util.Result;
import com.qmth.teachcloud.common.util.ResultUtil;
import com.qmth.teachcloud.common.util.ServletUtil;
import io.swagger.annotations.*;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * <p>
 * 入库申请 前端控制器
 * </p>
 *
 * @author xf
 * @since 2021-03-23
 */
@Api(tags = "入库申请Controller")
@RestController
@RequestMapping(ApiConstant.DEFAULT_URI_PREFIX + SystemConstant.PREFIX_URL_EXAM + "/task")
@Validated
public class ExamTaskApplyController {

    @Resource
    private ExamTaskService examTaskService;

    @Resource
    private PrintCommonService printCommonService;

    @Resource
    private ExamTaskPrintService examTaskPrintService;

    @Resource
    TaskService taskService;

    @Resource
    ActivitiService activitiService;

    @Resource
    TFFlowJoinService tfFlowJoinService;


    /**
     * 入库申请-查询
     *
     * @param auditStatus
     * @param cardRuleId
     * @param courseCode
     * @param paperNumber
     * @param startTime
     * @param endTime
     * @param userName    命题老师名称
     * @param pageNumber
     * @param pageSize
     * @return
     */
    @ApiOperation(value = "入库申请-分页查询")
    @RequestMapping(value = "/apply_list", method = RequestMethod.POST)
    public Result taskApplyList(@RequestParam(value = "semesterId", required = false) Long semesterId,
                                @RequestParam(value = "examId", required = false) Long examId,
                                @RequestParam(value = "auditStatus", required = false) String auditStatus,
                                @RequestParam(value = "cardRuleId", required = false) String cardRuleId,
                                @RequestParam(value = "courseCode", required = false) String courseCode,
                                @RequestParam(value = "paperNumber", required = false) String paperNumber,
                                @RequestParam(value = "startTime", required = false) Long startTime,
                                @RequestParam(value = "endTime", required = false) Long endTime,
                                @RequestParam(value = "userName", required = false) String userName,
                                @RequestParam @Min(SystemConstant.PAGE_NUMBER_MIN) Integer pageNumber,
                                @RequestParam @Min(SystemConstant.PAGE_SIZE_MIN) @Max(SystemConstant.PAGE_SIZE_MAX) Integer pageSize) {
        if (semesterId == null) {
            throw ExceptionResultEnum.ERROR.exception("请选择学期");
        }
        return ResultUtil.ok(examTaskService.listTaskApply(semesterId, examId, auditStatus, SystemConstant.convertIdToLong(cardRuleId), courseCode, paperNumber, startTime, endTime, userName, pageNumber, pageSize));
    }

    /**
     * 入库申请-删除
     */
    @ApiOperation(value = "入库申请-删除")
    @RequestMapping(value = "/apply_delete", method = RequestMethod.POST)
    @OperationLogDetail(customizedOperationType = CustomizedOperationTypeEnum.DELETE)
    public Result applyDelete(@RequestParam Long id) {
        examTaskService.applyDelete(id);
        return ResultUtil.ok(true);
    }

    /**
     * 根据命题任务ID查询单个数据
     *
     * @param examTaskId 命题任务ID
     * @return Result
     */
    @ApiOperation(value = "根据命题任务ID查询任务详情数据")
    @RequestMapping(value = "/apply_get_one", method = RequestMethod.POST)
    public Result applyGetOne(@RequestParam(value = "examTaskId") Long examTaskId,
                              @RequestParam(value = "source", required = false) String source) {
        SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
        ExamTaskDetailCardDto detail = examTaskService.applyGetOne(examTaskId, source);
        if (Objects.nonNull(detail) && Objects.nonNull(detail.getFlowId())) {
            Task task = taskService.createTaskQuery().processInstanceId(detail.getFlowId())
                    .taskCandidateOrAssigned(String.valueOf(sysUser.getId())).singleResult();
            if (Objects.nonNull(task)) {
                detail.setFlowTaskId(task.getId());
            } else {
                List<TFFlowJoin> tfFlowJoinList = tfFlowJoinService.findByObjectId(Long.parseLong(detail.getExamTaskId()));
                String flowId = null;
                TFFlowJoin tfFlowJoin = null;
                if (Objects.nonNull(tfFlowJoinList) && tfFlowJoinList.size() > 1) {
                    tfFlowJoin = tfFlowJoinList.get(tfFlowJoinList.size() - 1);
                } else if (Objects.nonNull(tfFlowJoinList) && tfFlowJoinList.size() == 1) {
                    tfFlowJoin = tfFlowJoinList.get(0);
                }
                flowId = Objects.nonNull(tfFlowJoin) ? String.valueOf(tfFlowJoin.getFlowId()) : flowId;
                task = taskService.createTaskQuery().processInstanceId(detail.getFlowId())
                        .taskCandidateOrAssigned(String.valueOf(sysUser.getId())).singleResult();
                if (Objects.nonNull(task)) {
                    detail.setFlowTaskId(task.getId());
                    detail.setFlowId(flowId);
                }
            }
        }
        return ResultUtil.ok(detail);
    }

    /**
     * 入库申请-立即申请-提交
     *
     * @param examTaskDetail 命题任务详情对象
     * @return Result
     */
    @ApiOperation(value = "入库申请-暂存/提交")
    @RequestMapping(value = "/apply_save", method = RequestMethod.POST)
    @OperationLogDetail(customizedOperationType = CustomizedOperationTypeEnum.EDIT)
    public Result taskApplySave(@RequestBody ExamTaskDetail examTaskDetail) throws IOException {
        Map<String, Object> map = examTaskService.saveExamTaskDetail(examTaskDetail);
        ExamTask examTask = examTaskService.getById(examTaskDetail.getExamTaskId());
        if (examTaskDetail.getOperateType().equals(ExamStatusEnum.SUBMIT.name()) && (Objects.nonNull(examTask.getReview()) && !examTask.getReview())) {
            // 校验是否可以提交打印状态
            printCommonService.checkDataNew(examTask.getSchoolId(), examTask.getExamId(), examTask.getCourseCode(), examTask.getPaperNumber(), (SysUser) ServletUtil.getRequestUser());
        }
        Boolean sendFlowMq = (Boolean) map.get(SystemConstant.SEND_FLOW_MQ);
        if (Objects.nonNull(sendFlowMq) && sendFlowMq) {
            activitiService.sendFlowTaskApproveMsg(map);
        }
        return ResultUtil.ok(true);
    }


    /**
     * 入库申请-撤销申请
     *
     * @param examTask 命题任务对象
     * @return Result
     */
    @ApiOperation(value = "入库申请-撤销申请")
    @RequestMapping(value = "/apply_status", method = RequestMethod.POST)
    @OperationLogDetail(customizedOperationType = CustomizedOperationTypeEnum.UPDATE)
    public Result taskApplyStatus(@RequestBody ExamTask examTask) {
        Map<String, Object> map = examTaskService.status(examTask);
        activitiService.sendFlowTaskApproveMsg(map);
        return ResultUtil.ok(true);
    }


    /**
     * 入库申请-新建任务-保存
     *
     * @param examTaskApplyTemp
     * @return
     */
    @ApiOperation(value = "入库申请-新建任务-保存")
    @RequestMapping(value = "/submit_task_apply", method = RequestMethod.POST)
    @OperationLogDetail(customizedOperationType = CustomizedOperationTypeEnum.ADD)
    public Result submitTaskApply(@RequestBody ExamTaskApplyTemp examTaskApplyTemp) throws IOException {
        Map<String, Object> map = examTaskService.submitTaskApply(examTaskApplyTemp);
        ExamTask examTask = (ExamTask) map.get(SystemConstant.EXAM_TASK);
        if (Objects.nonNull(examTask.getReview()) && !examTask.getReview()) {
            // 校验是否可以提交打印状态
            printCommonService.checkDataNew(examTask.getSchoolId(), examTask.getExamId(), examTask.getCourseCode(), examTask.getPaperNumber(), (SysUser) ServletUtil.getRequestUser());
        }
        Boolean sendFlowStartMq = (Boolean) map.get(SystemConstant.SEND_FLOW_START_MQ);
        Boolean sendFlowMq = (Boolean) map.get(SystemConstant.SEND_FLOW_MQ);
        if (Objects.nonNull(sendFlowStartMq) && sendFlowStartMq) {
            activitiService.sendFlowStartMsg(examTask.getFlowId());
        } else if (Objects.nonNull(sendFlowMq) && sendFlowMq) {
            activitiService.sendFlowTaskApproveMsg(map);
        }
        return ResultUtil.ok();
    }

    /**
     * 印刷室列表
     *
     * @return
     */
    @ApiOperation(value = "印刷室列表")
    @RequestMapping(value = "/list_task_print_house", method = RequestMethod.POST)
    public Result listTaskPrintHouse() {
        return ResultUtil.ok(examTaskPrintService.listHouse());
    }

    @ApiOperation(value = "题卡标题查询")
    @RequestMapping(value = "/find_card_title", method = RequestMethod.POST)
    @ApiResponses({@ApiResponse(code = 200, message = "查询成功", response = Result.class)})
    public Result findCardTitle(@ApiParam(value = "题卡规则id", required = true) @RequestParam String cardRuleId) {
        return ResultUtil.ok((Object) examTaskService.findCardTitle(SystemConstant.convertIdToLong(cardRuleId)));
    }

    @ApiOperation(value = "命题任务-考试对象查询")
    @RequestMapping(value = "/find_exam_object", method = RequestMethod.POST)
    @ApiResponses({@ApiResponse(code = 200, message = "查询成功", response = Result.class)})
    public Result findExamObject(@ApiParam(value = "考试ID", required = true) @RequestParam Long examId,
                                 @ApiParam(value = "试卷编号", required = true) @RequestParam String paperNumber) {
        return ResultUtil.ok(examTaskService.findExamObjectDtoByPaperNumber(examId, paperNumber));
    }

    @ApiOperation(value = "入库申请-考生对象查询")
    @RequestMapping(value = "/find_exam_task_student_object", method = RequestMethod.POST)
    @Transactional(rollbackFor = Exception.class)
    @ApiResponses({@ApiResponse(code = 200, message = "{\"success\":true}", response = Result.class)})
    public Result findExamTaskStudentObject(@RequestParam ExamObjectType examObjectType,
                                            @RequestParam(required = false) String courseCode) throws Exception {
        SysUser requestUser = (SysUser) ServletUtil.getRequestUser();
        return ResultUtil.ok(examTaskService.findExamTaskStudentObject(examObjectType, courseCode, requestUser));
    }

    @ApiOperation(value = "入库申请-导入考生对象")
    @RequestMapping(value = "/exam_task_exam_student_import", method = RequestMethod.POST)
    @Transactional(rollbackFor = Exception.class)
    @ApiResponses({@ApiResponse(code = 200, message = "{\"success\":true}", response = Result.class)})
    @OperationLogDetail(customizedOperationType = CustomizedOperationTypeEnum.IMPORT)
    public Result examTaskExamStudentImport(@RequestParam MultipartFile file) throws Exception {
        SysUser requestUser = (SysUser) ServletUtil.getRequestUser();
        return ResultUtil.ok(examTaskService.examTaskExamStudentImport(file, requestUser));
    }

    @ApiOperation(value = "入库申请-题库试卷列表")
    @RequestMapping(value = "/page_tiku_paper", method = RequestMethod.POST)
    @Transactional(rollbackFor = Exception.class)
    @ApiResponses({@ApiResponse(code = 200, message = "{\"success\":true}", response = Result.class)})
    public Result pageTikuPaper(@ApiParam(value = "课程代码", required = true) @RequestParam String courseCode,
                                @ApiParam(value = "试卷名称") @RequestParam(value = "paperName", required = false) String paperName,
                                @ApiParam(value = "教师工号") @RequestParam(value = "account", required = false) String account,
                                @RequestParam @Min(SystemConstant.PAGE_NUMBER_MIN) Integer pageNumber,
                                @RequestParam @Min(SystemConstant.PAGE_SIZE_MIN) @Max(SystemConstant.PAGE_SIZE_MAX) Integer pageSize) {
        return ResultUtil.ok(examTaskService.pageTikuPaper(courseCode, paperName, account, pageNumber, pageSize));
    }

    @ApiOperation(value = "入库申请-题库试卷包")
    @RequestMapping(value = "/get_tiku_paper_data", method = RequestMethod.POST)
    @Transactional(rollbackFor = Exception.class)
    @ApiResponses({@ApiResponse(code = 200, message = "{\"success\":true}", response = Result.class)})
    public Result getTikuPaperData(@ApiParam(value = "考试ID", required = true) @RequestParam(value = "examId") Long examId,
                                   @ApiParam(value = "题库试卷ID", required = true) @RequestParam(value = "paperId") Long paperId,
                                   @ApiParam(value = "唯一标识") @RequestParam(value = "uuid", required = false) String uuid) {
        return ResultUtil.ok(examTaskService.getTikuPaperData(examId, paperId, uuid));
    }
}