JzPeiXun/src/main/java/com/aijia/kmt/controller/KmtExerciseController.java

package com.aijia.kmt.controller;


import com.aijia.basic.utils.StringUtils;
import com.aijia.core.security.exception.CommonException;
import com.aijia.core.web.BaseController;
import com.aijia.core.web.ResponseConstant;
import com.aijia.core.web.ResponseEntity;
import com.aijia.kmt.service.*;
import com.aijia.kmt.vo.*;
import com.aijia.kmt.vo.rollbackai.AddExerciseQuestionRequest;
import com.aijia.kmt.vo.rollbackai.ExerciseBooksEditRequest;
import com.aijia.kmt.vo.rollbackai.ExerciseQuestionDealRequest;
import com.aijia.kmt.vo.rollbackai.ExerciseQuestionsEditRequest;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.collections4.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 *
 * kmt练习册
 * @author chchen
 * 2019-01-14
 */
@RestController
@RequestMapping("/api/train/kmt/exercise")
@Api(value = "kmt练习册接口", tags = "kmt练习册接口")
public class KmtExerciseController extends BaseController {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private TokenManager tokenManager;

    @Autowired
    private KmtQualityQuestionsService kmtQualityQuestionsService;

    @Autowired
    private KmtExerciseQuestionService kmtExerciseQuestionService;

    @Autowired
    private KmtExerciseMapperService kmtExerciseMapperService;

    @Autowired
    private KmtExerciseSubmitService kmtExerciseSubmitService;
    @Autowired
    private KmtExerciseQuestionDealService kmtExerciseQuestionDealService;

    @RequestMapping(value = "/getHandlingQuestions", method = RequestMethod.POST)
    @ApiOperation(value = "待加工/待审核题目", httpMethod = "POST",  notes = "待加工/待审核题目")
    public ResponseEntity getHandlingQuestions(@RequestParam(name = "accessToken") String accessToken,
                                               @RequestBody ExerciseQuestionsRequest request) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            String userId = tokenManager.getUserId(accessToken);
            responseEntity = kmtExerciseQuestionService.findExerciseQuestions(userId, request);
        } catch (Exception e) {
            logger.error("入参={}", request);
            logger.error("待加工/待审核题目", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        return responseEntity;
    }

    @RequestMapping(value = "/V1/submit2Auditing", method = RequestMethod.POST)
    @ApiOperation(value = "提交审核/发布", httpMethod = "POST",  notes = "提交审核/发布")
    public ResponseEntity submit2AuditingV1(@RequestParam(name = "accessToken") String accessToken,
                                            @RequestBody AuditingV1Request request) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            String userId = tokenManager.getUserId(accessToken);
            responseEntity = kmtExerciseSubmitService.submit2Auditing(request, userId);
        } catch (CommonException e) {
            return responseEntity.failure(ResponseConstant.CODE_500, e.getMessage());
        } catch (Exception e){
            logger.error("入参={}", request);
            logger.error("异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }

    @RequestMapping(value = "/findQuestionAttributeFilter", method = RequestMethod.POST)
    @ApiOperation(value = "查询题目类型筛选项", httpMethod = "POST",  notes = "查询题目类型筛选项")
    public ResponseEntity findQuestionAttributeFilter(@RequestParam(name = "accessToken") String accessToken) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("list", kmtExerciseQuestionService.findQuestionAttributeFilter());
            responseEntity.success(data, "成功");
        } catch (Exception e) {
            logger.error("练习册筛选条件异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }

    @RequestMapping(value = "/findExerciseBooks", method = RequestMethod.POST)
    @ApiOperation(value = "查询练习册", httpMethod = "POST",  notes = "查询练习册")
    public ResponseEntity findExerciseBooks(@RequestParam(name = "accessToken") String accessToken, @RequestBody ExerciseConditionRequest request) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("list", kmtExerciseMapperService.findExerciseBooks(request, tokenManager.getUserId(accessToken)));
            responseEntity.success(data, "成功");
        } catch (Exception e) {
            logger.error("查询练习册", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }

    @RequestMapping(value = "/findExerciseBookDetail", method = RequestMethod.POST)
    @ApiOperation(value = "查询题目单元课时", httpMethod = "POST",  notes = "查询题目单元课时")
    public ResponseEntity findExerciseBookDetail(@RequestParam(name = "accessToken") String accessToken, @RequestBody ExerciseBookIdDealTypeRequest request) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            Map<String, Object> data = new HashMap<>();
            String  userId = tokenManager.getUserId(accessToken);
            //是管理员
            int type = 1;
            if(!userId.equals(request.getUserId())){
                type = 2;
            }

            data.put("units", kmtExerciseMapperService.findExerciseBookDetail(request, userId,type));
            responseEntity.success(data, "成功");
        } catch (Exception e) {
            logger.error("练习册筛选条件异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }

    @RequestMapping(value = "/getKmtHandlingQuestions", method = RequestMethod.POST)
    @ApiOperation(value = "kmt题库查询待加工/待审核的题目", httpMethod = "POST",  notes = "kmt题库查询待加工/待审核的题目")
    public ResponseEntity getKmtHandlingQuestions(@RequestParam(name = "accessToken") String accessToken, @RequestBody KmtHandlingQuestionRequest request) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            responseEntity.success(kmtQualityQuestionsService.getKmtHandlingQuestions(request, tokenManager.getUserId(accessToken)), "成功");
        } catch (Exception e) {
            logger.error("练习册筛选条件异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        return responseEntity;
    }

    @RequestMapping(value = "/submitKmtQuestions2Auditing", method = RequestMethod.POST)
    @ApiOperation(value = "kmt题目提交审核", httpMethod = "POST",  notes = "kmt题目提交审核")
    public ResponseEntity submitKmtQuestions2Auditing(@RequestParam(name = "accessToken") String accessToken, @RequestBody AuditingRequest request) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            logger.info(JSON.toJSONString(request));
            String userId = tokenManager.getUserId(accessToken);
            responseEntity = kmtQualityQuestionsService.submitKmtQuestions2Auditing(request, userId);
        } catch (Exception e) {
            logger.error("练习册筛选条件异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        return responseEntity;
    }

    @RequestMapping(value = "/findQuestionListByParentId", method = RequestMethod.POST)
    @ApiOperation(value = "查询大小题目", httpMethod = "POST",  notes = "删除题目")
    public ResponseEntity findQuestionListByParentId(@RequestParam(name = "accessToken") String accessToken, @RequestBody ParentIdListRequest request) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            responseEntity = kmtQualityQuestionsService.findQuestionListByParentId(request.getParentIdList());
        } catch (Exception e) {
            logger.error("练习册筛选条件异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        return responseEntity;
    }


    @RequestMapping(value = "/addOrEditExerciseQuestion", method = RequestMethod.POST)
    @ApiOperation(value = "新增、编辑题目", httpMethod = "POST", notes = "推荐题回调接口")
    public ResponseEntity addOrEditExerciseQuestion(@RequestParam(name = "accessToken") String accessToken,
                                                    @RequestBody AddExerciseQuestionRequest request) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            String userId = tokenManager.getUserId(accessToken);
            return kmtExerciseQuestionDealService.addOrEditExerciseQuestion(userId, request);
        } catch (Exception e) {
            logger.error("异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }


    @RequestMapping(value = "/moveExerciseQuestion", method = RequestMethod.POST)
    @ApiOperation(value = "移动题目", httpMethod = "POST", notes = "推荐题回调接口")
    public ResponseEntity moveExerciseQuestion(@RequestParam(name = "accessToken") String accessToken,
                                               @RequestBody ExerciseQuestionDealRequest request) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            String userId = tokenManager.getUserId(accessToken);
            return kmtExerciseQuestionDealService.moveExerciseQuestion(userId, request);
        } catch (Exception e) {
            logger.error("异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }

    @RequestMapping(value = "/findEditExerciseBooks", method = RequestMethod.POST)
    @ApiOperation(value = "题目修改查询练习册", httpMethod = "POST", notes = "题目修改查询练习册")
    public ResponseEntity findEditExerciseBooks(@RequestParam(name = "accessToken") String accessToken,
                                               @RequestBody ExerciseBooksEditRequest request) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            responseEntity = kmtExerciseQuestionDealService.findEditExerciseBooks(request);
        } catch (Exception e) {
            logger.error("异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        return responseEntity;
    }

    @RequestMapping(value = "/findEditExerciseQuestions", method = RequestMethod.POST)
    @ApiOperation(value = "题目修改查询练习册", httpMethod = "POST", notes = "题目修改查询练习册")
    public ResponseEntity findEditExerciseQuestions(@RequestParam(name = "accessToken") String accessToken,
                                               @RequestBody ExerciseQuestionsEditRequest request) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            responseEntity = kmtExerciseQuestionDealService.findEditExerciseQuestions(request);

        } catch (Exception e) {
            logger.error("异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        return responseEntity;
    }

    @RequestMapping(value = "/removeQuestionNumMark", method = RequestMethod.POST)
    @ApiOperation(value = "抹除题目题号", httpMethod = "POST", notes = "抹除题目题号")
    public ResponseEntity removeQuestionNumMark(@RequestParam(name = "accessToken") String accessToken,
                                               @RequestBody QuestionNumMarkRemoveVo request) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            String userId = tokenManager.getUserId(accessToken);
            responseEntity = kmtExerciseQuestionDealService.removeQuestionNumMark(userId, request);
        } catch (Exception e) {
            logger.error("异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }


    @RequestMapping(value = "/publishQuestion", method = RequestMethod.POST)
    @ApiOperation(value = "发布题目", httpMethod = "POST",  notes = "发布题目")
    public ResponseEntity publishQuestion(@RequestParam(name = "accessToken") String accessToken,
                                          @RequestBody QuestionPublishRequest request) {
        long start = System.currentTimeMillis();
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            List<String> questionIdList = request.getQuestionIds();
            if (CollectionUtils.isEmpty(questionIdList)) {
                responseEntity.failure("请先选择题目");
                return responseEntity;
            }
            String userId = tokenManager.getUserId(accessToken);
            responseEntity = kmtExerciseSubmitService.publishQuestion(request, userId);
        } catch (CommonException e) {
            throw e;
        } catch (Exception e){
            logger.error("入参={}", request);
            logger.error("异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "暂未加载到数据，请稍后重试");
        }
        logger.info(accessToken + ":" + (System.currentTimeMillis() - start));
        return responseEntity;
    }


}