sys/src/main/java/com/ssj/api/controller/ApiManagerTeacherController.java

package com.ssj.api.controller;

import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import cn.afterturn.easypoi.excel.entity.enmus.ExcelType;
import cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity;
import com.alibaba.fastjson.JSONObject;
import com.ssj.api.domain.vo.homework.CheckDetailVO;
import com.ssj.api.domain.vo.statistics.HomeworkReq;
import com.ssj.api.domain.vo.statistics.ListReq;
import com.ssj.api.domain.vo.teacher.TeacherAddReq;
import com.ssj.api.domain.vo.teacher.TeacherChangeReq;
import com.ssj.api.domain.vo.teacher.TeacherDelReq;
import com.ssj.api.domain.vo.teacher.TeacherReq;
import com.ssj.bean.sys.imlibuser.TbClassTeacherTemp;
import com.ssj.bean.weixin.libmy.domain.TbLibManager;
import com.ssj.framework.core.common.controller.BaseController;
import com.ssj.framework.core.util.Constant;
import com.ssj.framework.core.util.PasswordUtil;
import com.ssj.framework.core.util.ResponseConstant;
import com.ssj.framework.core.util.ResponseEntity;
import com.ssj.framework.weixin.util.DateUtil;
import com.ssj.service.kmt.correctsys.dto.HomeworkPictureCheckDto;
import com.ssj.service.kmt.correctsys.service.KmtCorrectSysService;
import com.ssj.service.sys.homework.service.HomeworkPictureService;
import com.ssj.service.sys.imlibuser.service.TbClassTeacherTempService;
import com.ssj.service.weixin.library.service.IBookManagerService;
import com.ssj.service.weixin.user.service.UserService;
import com.ssj.statistics.service.IStatisticsService;
import com.ssj.statistics.service.ITeacherPayService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

@Api(value = "平台批改老师相关", tags = "平台批改老师相关")
@RestController
@RequestMapping("/api/teacher")
public class ApiManagerTeacherController extends BaseController {
	
	@Autowired
	private IBookManagerService managerService;

	@Autowired
	private HomeworkPictureService pictureService;

    @Autowired
    private TbClassTeacherTempService tbLibImTeacherTempService;

    @Autowired
    private IStatisticsService statisticsService;

    @Autowired
    private ITeacherPayService teacherPayService;

    @Autowired
    private KmtCorrectSysService kmtCorrectSysService;


	@RequestMapping(value = "/list", method = RequestMethod.POST)
    @ApiOperation(value = "获取平台批改老师列表接口",  notes = "获取平台批改老师列表接口")
    public ResponseEntity list(@RequestParam(name = "accessToken") String accessToken,@RequestBody TeacherReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        Map<String,Object> data=new HashMap<>(2);
        Map<String,Object> params=new HashMap<>(2);
        try {
        	params.put("type",30);
        	params.put("name",req.getName());
        	params.put("mobile",req.getMobile());
			Page<Map<String,Object>> list = managerService.findTeacherManagerList(params,initPage(req.getPageNo(),req.getPageSize()));
        	data.put("list",list.getContent());
        	data.put("totalNums",list.getTotalElements());
        	responseEntity.success(data,"获取平台批改老师列表成功！");
        } catch (Exception e) {
            logger.error("获取平台批改老师列表接口", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        logger.info("第三方调用接口【/open/api/teacher/list】，返回结果："+JSONObject.toJSONString(responseEntity));
        return responseEntity;
    }


    @RequestMapping(value = "/delTeacher", method = RequestMethod.POST)
    @ApiOperation(value = "注销平台批改老师接口",  notes = "注销平台批改老师接口")
    public ResponseEntity delTeacher(@RequestParam(name = "accessToken") String accessToken,@RequestBody TeacherDelReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            //查询老师是否有作业未批改
            String userId = tokenManager.getUserId(accessToken);

            TbLibManager managerAdmin = managerService.findAllByUserIdAndTypeAndState(userId,40,1);
            if(Objects.isNull(managerAdmin)){
                responseEntity.failure(ResponseConstant.CODE_000, "您不是管理员，无权进行此操作！");
                return responseEntity;
            }

            TbLibManager manager = managerService.getById(req.getId());
            if(Objects.isNull(manager)){
                responseEntity.failure(ResponseConstant.CODE_000, "此老师数据不存在，请检查传参！");
                return responseEntity;
            }

            long count = pictureService.countByTeacherIdAndIsFeedback(manager.getUserId(),0);
            if(count >0){
                responseEntity.failure(ResponseConstant.CODE_000, "此老师有作业未批改完不能注销！");
                return responseEntity;
            }

            manager.setState(2);
            manager.setIsCancelled(1);
            manager.setCancelledTime(new Date());
            managerService.save(manager);
            //登录状态失效
            tokenManager.delToken(manager.getUserId());

            //注销用户(删除用户)
            //userService.delete(manager.getUserId());

            responseEntity.success("注销成功！");
        } catch (Exception e) {
            logger.error("获取平台批改老师列表接口", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        logger.info("第三方调用接口【/open/api/teacher/delTeacher】，返回结果："+JSONObject.toJSONString(responseEntity));
        return responseEntity;
    }

    @RequestMapping(value = "/addTeacher", method = RequestMethod.POST)
    @ApiOperation(value = "添加平台批改老师接口",  notes = "添加平台批改老师接口")
    public ResponseEntity addTeacher(@RequestParam(name = "accessToken") String accessToken,@RequestBody TeacherAddReq req) {
        ResponseEntity responseEntity = new ResponseEntity();

        String userId = tokenManager.getUserId(accessToken);

        TbLibManager managerAdmin = managerService.findAllByUserIdAndTypeAndState(userId,40,1);
        if(Objects.isNull(managerAdmin)){
            responseEntity.failure(ResponseConstant.CODE_000, "您不是管理员，无权进行此操作！");
            return responseEntity;
        }

        try {
            TbClassTeacherTemp tbLibImTeacherTemp=new TbClassTeacherTemp();
            tbLibImTeacherTemp.setLeagueName("平台批改老师");
            tbLibImTeacherTemp.setTeacherName(req.getName());
            tbLibImTeacherTemp.setTeacherPhone(req.getMobile());
            tbLibImTeacherTemp.setSubject(req.getCourseName());
            tbLibImTeacherTemp.setInspectorId(req.getTeacherId());
            tbLibImTeacherTemp.setIsCorrect(1);
            List<TbClassTeacherTemp> list = new ArrayList<>();
            list.add(tbLibImTeacherTemp);
            int num = tbLibImTeacherTempService.insertBatchTbAllImTeacher(list);
            if(num<1){
                responseEntity.failure(ResponseConstant.CODE_000, list.get(0).getErrorReason());
                return responseEntity;
            }
            responseEntity.success("添加成功");
        } catch (Exception e) {
            logger.error("添加平台批改老师接口", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        logger.info("第三方调用接口【/open/api/teacher/addTeacher】，返回结果："+JSONObject.toJSONString(responseEntity));
        return responseEntity;
    }

    @RequestMapping(value = "/checkList", method = RequestMethod.POST)
    @ApiOperation(value = "获取质检员老师列表接口",  notes = "获取质检员老师列表接口")
    public ResponseEntity checkList(@RequestParam(name = "accessToken") String accessToken) {
        ResponseEntity responseEntity = new ResponseEntity();
        Map<String,Object> data=new HashMap<>(2);
        try {
            List<TbLibManager> managerList = managerService.findByType(Constant.CHECK_TEACHER_TYPE);
            List<Map<String, Object>> list  = new ArrayList<>();
            managerList.forEach(o->{
                Map<String, Object> map = new HashMap<>();
                map.put("teacherId",o.getUserId());
                map.put("teacherName",o.getName());
                list.add(map);
            });
            data.put("list",list);
            responseEntity.success(data,"获取平台批改老师列表成功！");
        } catch (Exception e) {
            logger.error("获取质检员老师列表接口异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/changeInspector", method = RequestMethod.POST)
    @ApiOperation(value = "更改老师所属质检员",  notes = "更改老师所属质检员")
    public ResponseEntity changeInspector(@RequestParam(name = "accessToken") String accessToken,@RequestBody TeacherChangeReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        Map<String,Object> data=new HashMap<>(2);
        try {
            TbLibManager manager = managerService.getById(req.getId());
            if(Objects.isNull(manager)){
                responseEntity.failure(ResponseConstant.CODE_000, "老师数据不存在！");
                return responseEntity;
            }
            manager.setInspectorId(req.getTeacherId());
            managerService.save(manager);
            responseEntity.success(data,"更改成功！");
        } catch (Exception e) {
            logger.error("更改老师所属质检员异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        logger.info("第三方调用接口【/open/api/teacher/changeInspector】，接收参数："+JSONObject.toJSONString(req));
        return responseEntity;
    }

    @RequestMapping(value = "/statisticsList", method = RequestMethod.POST)
    @ApiOperation(value = "数据统计列表",  notes = "数据统计列表")
    public ResponseEntity statisticsList(@RequestParam(name = "accessToken") String accessToken,@RequestBody ListReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        Map<String,Object> data=new HashMap<>(2);
        Map<String,Object> params=new HashMap<>(2);
        try {
            params.put("beginDate",req.getBeginDate());
            params.put("endDate",req.getEndDate());
            params.put("teacherName",req.getTeacherName());
            Map<String,Object> total = statisticsService.findTotalData(params);
            Page<Map<String,Object>> page = statisticsService.statisticsList(params,initPage(req.getPageNo(),req.getPageSize()));
            data.putAll(total);
            data.put("list",page.getContent());
            data.put("pages",Integer.parseInt(Long.toString(page.getTotalElements())));
            responseEntity.success(data,"获取数据统计列表成功");
        } catch (Exception e) {
            logger.error("数据统计列表异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/initStatisticsData", method = RequestMethod.POST)
    @ApiOperation(value = "数据统计列表",  notes = "数据统计列表")
    public ResponseEntity statisticsList(@RequestParam(name = "accessToken") String accessToken,String date) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            statisticsService.addStatisticsData(date);
            responseEntity.success("生成数据统计列表成功");
        } catch (Exception e) {
            logger.error("数据统计列表异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/initTeacherPayData", method = RequestMethod.POST)
    @ApiOperation(value = "手动生成老师薪酬列表",  notes = "手动生成老师薪酬列表")
    public ResponseEntity initTeacherPayData(@RequestParam(name = "accessToken") String accessToken,String date) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            statisticsService.addTeacherSalarysData(date);
            responseEntity.success("生成数据统计列表成功");
        } catch (Exception e) {
            logger.error("数据统计列表异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/errorList", method = RequestMethod.POST)
    @ApiOperation(value = "查看报错列表",  notes = "数据统计列表")
    public ResponseEntity errorList(@RequestParam(name = "accessToken") String accessToken,@RequestBody ListReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        Map<String,Object> params=new HashMap<>(4);
        try {
            params.put("beginDate",req.getBeginDate());
            params.put("endDate",req.getEndDate());
            params.put("teacherId",req.getTeacherId());
            params.put("subject",req.getSubject());
            Map<String,Object> data = statisticsService.errorList(params,initPage(req.getPageNo(),req.getPageSize()));
            responseEntity.success(data,"获取数据统计列表成功");
        } catch (Exception e) {
            logger.error("数据统计列表异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/checkDetailList", method = RequestMethod.POST)
    @ApiOperation(value = "获取作业列表",  notes = "获取作业列表")
    public ResponseEntity checkDetailList(@RequestParam(name = "accessToken") String accessToken,@RequestBody HomeworkReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            Map<String,Object> data=new HashMap<>(2);
            List<CheckDetailVO> list = statisticsService.checkDetailList(req.getHomeworkId());
            data.put("list",list);
            responseEntity.success(data,"获取数据统计列表成功");
        } catch (Exception e) {
            logger.error("数据统计列表异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/checkHomeworkDetailList", method = RequestMethod.POST)
    @ApiOperation(value = "查询报错图片列表数据",  notes = "查询报错图片列表数据")
    public ResponseEntity checkHomeworkDetailList(@RequestParam(name = "accessToken") String accessToken,@RequestBody HomeworkReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            List<HomeworkPictureCheckDto> homeworkPictures = kmtCorrectSysService.checkHomeworkDetailList(req.getHomeworkId(),accessToken);
            Map<String, Object> data = new HashMap<>();
            data.put("homeworkPictures", homeworkPictures);
            responseEntity.success(data, "请求成功");
        } catch (Exception e) {
            logger.error("数据统计列表异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/pictureDetail", method = RequestMethod.POST)
    @ApiOperation(value = "作业批改痕迹",  notes = "作业批改痕迹")
    public ResponseEntity pictureDetail(@RequestParam(name = "accessToken") String accessToken,@RequestBody HomeworkReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            Map<String,Object> data=pictureService.pictureDetail(req.getPictureId());
           responseEntity.success(data,"获取成功");
        } catch (Exception e) {
            logger.error("作业批改痕迹异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/salaryList", method = RequestMethod.POST)
    @ApiOperation(value = "薪酬列表",  notes = "薪酬列表")
    public ResponseEntity salaryList(@RequestParam(name = "accessToken") String accessToken,@RequestBody TeacherDelReq req) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            Map<String,Object> data=new HashMap<>(2);
            TbLibManager manager = managerService.getById(req.getId());
            if(Objects.isNull(manager)){
                return responseEntity.failure(ResponseConstant.CODE_000, "请检查传参id是否正确！");
            }
            List<Map<String,Object>> list = getSalaryList(manager.getUserId());
            data.put("list",list);
            data.put("teacherName",manager.getName());
            responseEntity.success(data,"获取列表成功");
        } catch (Exception e) {
            logger.error("薪酬列表异常", e);
            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
        }
        return responseEntity;
    }
    @RequestMapping(value = "/exportSalaryList", method = RequestMethod.GET)
    @ApiOperation(value = "导出薪酬列表",  notes = "导出薪酬列表")
    @ResponseBody
    public void exportSalaryList(@RequestParam(name = "accessToken") String accessToken,String id) {
        ServletOutputStream os = null;
        try {
            String libName="老师薪酬统计";
            //获得输出流
            os = response.getOutputStream();
            //清空输出流
            response.reset();

            TbLibManager manager = managerService.getById(id);
            exportExcelHead(response,manager.getName()+libName);
            List<Map<String,Object>> list = getSalaryList(manager.getUserId());
            /**
             * workDate	string	list	日期
             * correctNums	int	list	批注总张数
             * overtimeNums	int	list	超时批注总张数
             * perkNums	int	list	高峰时段批注张数
             * perkEfficiency	String	list	高峰时段平均批注时间
             * errorNums	int	list	报错张数
             * accuracy	string	list	正确率
             * perkSalary	String	list	高峰时段薪资
             * otherSalary	String	list	其他时段薪资
             * salary	String	list	总薪资
             */
            StringBuilder head =  new StringBuilder();
            head.append("日期|workDate;批注总张数（张）|correctNums;超时批注总张数（张）|overtimeNums;高峰时段（18:00-20:00）批注张数（张）|perkNums;");
            head.append("高峰时段（18:00-20:00）平均批注时间（min/张）|perkEfficiency;报错张数（张）|errorNums;正确率|accuracy;");
            head.append("高峰时段薪资（元）|perkSalary;其他时段薪资（元）|otherSalary;总薪资（元）|salary");
            List<ExcelExportEntity> entity = addEntity(head.toString());
            //把我们构造好的bean对象放到params就可以了
            Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams(libName, libName, ExcelType.XSSF), entity,
                    list);
            workbook.write(os);
        }catch (IOException e) {
            logger.error("异常", e);
        } catch (Exception e) {
            logger.error("作业批改痕迹异常", e);
        }finally {
            if(os != null){
                try {
                    os.flush();
                    os.close();
                } catch (IOException e) {
                    logger.error("异常", e);
                }
            }
         }
    }

    @RequestMapping(value = "/exportStatisticsList", method = RequestMethod.GET)
    @ApiOperation(value = "导出数据统计列表",  notes = "导出数据统计列表")
    @ResponseBody
    public void exportStatisticsList(@RequestParam(name = "accessToken") String accessToken,String beginDate,String endDate,String teacherName) {
        ServletOutputStream os = null;
        try {
            String libName="数据统计";
            //获得输出流
            os = response.getOutputStream();
            //清空输出流
            response.reset();
            exportExcelHead(response,libName);
            Map<String,Object> params = new HashMap<>(4);
            params.put("beginDate",beginDate);
            params.put("endDate",endDate);
            params.put("teacherName",teacherName);
            Page<Map<String,Object>> page = statisticsService.statisticsList(params,initPage(1,100000));
            /**
             * teacherName	string	list	老师姓名
             * subject	string	list	科目
             * allSubject	string	list	老师拥有的科目，多科目英文逗号隔开，
             * correctNums	int	list	批注页数
             * overtimeNums	int	list	超时批注页数
             * notCorrectNums	int	list	未批注页数
             * notCommentNums	int	list	不批注页数
             * repeatNums	int	list	重复页数
             * accuracy	string	list	正确率
             * errorNums	int	list	报错页数
             */
            List<Map<String,Object>> list = new ArrayList<>();
            list.addAll(page.getContent());
            StringBuilder head =  new StringBuilder();
            head.append("姓名|teacherName;科目|subject;批注页数|correctNums;超时批注页数|overtimeNums;");
            head.append("未批注页数|notCorrectNums;不批注页数|notCommentNums;重复页数|repeatNums;");
            head.append("批注正确率|accuracy;报错页数|errorNums");
            List<ExcelExportEntity> entity = addEntity(head.toString());
            //把我们构造好的bean对象放到params就可以了
            Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams(libName, libName, ExcelType.XSSF), entity,
                    list);
            workbook.write(os);
        }catch (IOException e) {
            logger.error("异常", e);
        } catch (Exception e) {
            logger.error("作业批改痕迹异常", e);
        }finally {
            if(os != null){
                try {
                    os.flush();
                    os.close();
                } catch (IOException e) {
                    logger.error("异常", e);
                }
            }
        }
    }

    private List<Map<String,Object>> getSalaryList(String userId){
        //计算今天日期
        LocalDate date = LocalDate.now();
        int day = date.getDayOfMonth();
        LocalTime time = LocalTime.now();
        boolean lastMonth = day< 4 || (day==4 && time.getHour()<12);
        LocalDate localDate = lastMonth?date.minusMonths(2):date.minusMonths(1);
        int month = localDate.getMonthValue();
        int year = localDate.getYear();
        return teacherPayService.salaryList(userId,month,year);
    }

    private List<ExcelExportEntity> addEntity(String exportHead){
        List<ExcelExportEntity> entity = new ArrayList<>();
        String[] headArr = exportHead.split(";");
        for (String str:headArr){
            int index = str.indexOf("|");
            entity.add(new ExcelExportEntity(str.substring(0,index), str.substring(index+1)));
        }
        return  entity;
    }

    private void exportExcelHead(HttpServletResponse response, String fileName) throws Exception{
        String lastFileName = new String(fileName.getBytes("gb2312"), "ISO8859-1") +".xlsx";
        //设定输出文件头
        response.setHeader("Content-disposition", "attachment; filename="+ lastFileName);
        response.setContentType("application/vnd.ms-excel;charset=UTF-8");
        response.setCharacterEncoding("utf-8");
    }
}