package org.jeecg.modules.eam.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.xiaoymin.knife4j.core.util.CollectionUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Param;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.base.entity.SysUpload;
import org.jeecg.common.system.base.entity.SysUploadRela;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.eam.entity.CalibrationOrder;
import org.jeecg.modules.eam.entity.CalibrationOrderDetail;
import org.jeecg.modules.eam.entity.CalibrationOrderReport;
import org.jeecg.modules.eam.entity.Equipment;
import org.jeecg.modules.eam.service.ICalibrationOrderDetailService;
import org.jeecg.modules.eam.service.ICalibrationOrderReportService;
import org.jeecg.modules.eam.service.ICalibrationOrderService;
import org.jeecg.modules.eam.service.IEamEquipmentService;
import org.jeecg.modules.eam.vo.CalibrationOrderPage;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
 * @Description: 检定工单
 * @Author: jeecg-boot
 * @Date: 2023-04-23
 * @Version: V1.0
 */
@Api(tags = "检定工单")
@RestController
@RequestMapping("/eam/calibrationOrder")
@Slf4j
public class CalibrationOrderController {
    @Autowired
    private ICalibrationOrderService calibrationOrderService;
    @Autowired
    private ICalibrationOrderDetailService calibrationOrderDetailService;

    @Autowired
    private ICalibrationOrderReportService calibrationOrderReportService;
    @Autowired
    private IEamEquipmentService equipmentService;
//    @Autowired
//    private IUploadRelaService uploadRelaService;
//    @Autowired
//    private IUploadService uploadService;

    private ISysBaseAPI  sysBaseApi;
    /**
     * 分页列表查询
     *
     * @param calibrationOrder
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    //@AutoLog(value = "检定工单-分页列表查询")
    @ApiOperation(value = "检定工单-分页列表查询", notes = "检定工单-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<CalibrationOrder>> queryPageList(CalibrationOrder calibrationOrder,
                                                         @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                         @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                         HttpServletRequest req) {
        LambdaQueryWrapper<CalibrationOrder> wrapper = new LambdaQueryWrapper<>();
        if (calibrationOrder != null) {
            // 工单号
            if (calibrationOrder.getNum() != null) {
                wrapper.like(CalibrationOrder::getNum, calibrationOrder.getNum());
            }
            // 设备id
            if (calibrationOrder.getEquipmentId() != null) {
                wrapper.eq(CalibrationOrder::getEquipmentId, calibrationOrder.getEquipmentId());
            }
            // 创建人
            if (calibrationOrder.getCreateBy() != null) {
                wrapper.like(CalibrationOrder::getCreateBy, calibrationOrder.getCreateBy());
            }
            // 创建开始时间-结束时间
            if (calibrationOrder.getCreateStartDate() != null && calibrationOrder.getCreateEndDate() != null) {
                wrapper.ge(CalibrationOrder::getCreateTime, calibrationOrder.getCreateStartDate());
                wrapper.le(CalibrationOrder::getCreateTime, calibrationOrder.getCreateEndDate());
            }
            // 下发开始日期-结束时间
            if (calibrationOrder.getIssueStartDate() != null && calibrationOrder.getIssueEndDate() != null) {
                wrapper.ge(CalibrationOrder::getIssueTime, calibrationOrder.getIssueStartDate());
                wrapper.le(CalibrationOrder::getIssueTime, calibrationOrder.getIssueEndDate());
            }

        }
        Page<CalibrationOrder> page = new Page<>(pageNo, pageSize);
        IPage<CalibrationOrder> pageList = calibrationOrderService.page(page, wrapper);
        List<CalibrationOrder> records = pageList.getRecords();
        if (CollectionUtils.isNotEmpty(records)) {
            Set<String> equipmentIds = records.stream().map(CalibrationOrder::getEquipmentId).collect(Collectors.toSet());
            List<Equipment> equipmentList = equipmentService.listByIds(equipmentIds);
            records.forEach(re -> {
                if (CollectionUtils.isNotEmpty(equipmentList) && re.getEquipmentId() != null) {
                    equipmentList.forEach(ea -> {
                        if (re.getEquipmentId().equals(ea.getId())) {
                            // 设备名称
                            re.setNumName(ea.getName());
                            // 设备型号
                            re.setNumModel(ea.getModel());
                            // 设备编码
                            re.setNumCode(ea.getNum());
                            // 设备规格
                            re.setSpecification(ea.getSpecification());
                        }
                    });
                }
            });
        }
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param calibrationOrder
     * @return
     */
    @AutoLog(value = "检定工单-添加")
    @ApiOperation(value = "检定工单-添加", notes = "检定工单-添加")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody CalibrationOrder calibrationOrder) {
        calibrationOrderService.save(calibrationOrder);
        if (CollectionUtils.isNotEmpty(calibrationOrder.getCalibrationOrderDetailList())) {
            List<CalibrationOrderDetail> calibrationOrderDetailList = calibrationOrder.getCalibrationOrderDetailList();
            calibrationOrderDetailList.forEach(cod -> {
                cod.setId(null);
                cod.setCalibrationOrderId(calibrationOrder.getId());
            });
            calibrationOrderDetailService.saveBatch(calibrationOrderDetailList);
        }
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param calibrationOrder
     * @return
     */
    @AutoLog(value = "检定工单-编辑")
    @ApiOperation(value = "检定工单-编辑", notes = "检定工单-编辑")
//    @RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
    public Result<String> edit(@RequestBody CalibrationOrder calibrationOrder) {
        calibrationOrderService.updateById(calibrationOrder);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "检定工单-通过id删除")
    @ApiOperation(value = "检定工单-通过id删除", notes = "检定工单-通过id删除")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name = "id", required = true) String id) {
        CalibrationOrder calibrationOrder = calibrationOrderService.getById(id);
        calibrationOrder.setDelFlag(CommonConstant.DEL_FLAG_1);
        calibrationOrderService.updateById(calibrationOrder);
        calibrationOrderDetailService.delCalibrationOrderDetailByCalibrationOrderId(id);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "检定工单-批量删除")
    @ApiOperation(value = "检定工单-批量删除", notes = "检定工单-批量删除")
    //@RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
        this.calibrationOrderService.delBatchMain(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功！");
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    //@AutoLog(value = "检定工单-通过id查询")
    @ApiOperation(value = "检定工单-通过id查询", notes = "检定工单-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<CalibrationOrder> queryById(@RequestParam(name = "id", required = true) String id) {
        CalibrationOrder calibrationOrder = calibrationOrderService.getById(id);
        if (calibrationOrder == null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(calibrationOrder);

    }

    /**
     * 检定工单-提交
     *
     * @param id
     * @return
     */
    @ApiOperation(value = "检定工单-提交", notes = "检定工单-提交")
    @GetMapping(value = "/submit")
//    @RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:submit")
    public Result<String> submit(@RequestParam(name = "id", required = true) String id, HttpServletRequest request) {
        CalibrationOrder calibrationOrder = calibrationOrderService.getById(id);
        if (calibrationOrder == null) {
            return Result.error("未找到对应数据");
        }
        AtomicReference<String> judgmentResult = new AtomicReference<>("pass");
        // 数据判定依据
        if (calibrationOrder.getManagementMode().equals("data")) {
            List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.selectByMainId(id);
            AtomicReference<Boolean> decide = new AtomicReference<>(false);
            calibrationOrderDetails.forEach(cod -> {
                if (cod.getActualValue().isEmpty() || cod.getJudgmentResult().isEmpty()) {
                    decide.set(true);
                } else {
                    if (cod.getJudgmentResult().equals("fail")) {
                        judgmentResult.set(cod.getJudgmentResult());
                    }
                }
            });
            if (decide.get()) {
                return Result.error("实际测定值不能为空");
            }
        } else if (calibrationOrder.getManagementMode().equals("report")) {
            List<SysUploadRela> uploadRelaList = sysBaseApi.listByBusIdAndBusType(id, "calibration_order_photo");
            if (CollectionUtils.isEmpty(uploadRelaList)) {
                return Result.error("检定附件报告不能为空");
            } else {
                for (SysUploadRela uploadRela : uploadRelaList) {
                    SysUpload sysUpload = sysBaseApi.getUploadById(uploadRela.getUploadId());
                    if (sysUpload.getDescription().equals("fail")) {
                        judgmentResult.set(sysUpload.getDescription());
                    }
                    uploadRela.setUpload(sysUpload);
                }
            }
        }
        // 判定结果保存
        calibrationOrder.setCalibrationResult(judgmentResult.get());
        // 保存检定人检定时间
        String username = JwtUtil.getUserNameByToken(request);
        calibrationOrder.setCalibrationUserId(username);
        calibrationOrderService.updateById(calibrationOrder);
        return Result.OK("提交成功");

    }

    /**
     * 检定单撤回
     *
     * @param id
     * @return
     */
    @AutoLog(value = "检定单撤回")
    @ApiOperation(value = "检定单撤回", notes = "检定单撤回")
    @GetMapping(value = "/withdraw")
    public Result<String> withdraw(@RequestParam(name = "id", required = true) String id) {

        List<SysUploadRela> sysUploadRelaList =  sysBaseApi.listByBusIdAndBusType(id, "calibration_order_photo");
        if (CollectionUtils.isNotEmpty(sysUploadRelaList)) {
            return Result.error("撤回失败，检定附件报告已添加!");
        }
        CalibrationOrder calibrationOrder = new CalibrationOrder();
        calibrationOrder.setId(id);
        calibrationOrder.setStatus("2");
        calibrationOrderService.updateById(calibrationOrder);
        return Result.OK("撤回成功!");
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    //@AutoLog(value = "检定工单明细通过主表ID查询")
    @ApiOperation(value = "检定工单明细主表ID查询", notes = "检定工单明细-通主表ID查询")
    @GetMapping(value = "/queryCalibrationOrderDetailByMainId")
    public Result<List<CalibrationOrderDetail>> queryCalibrationOrderDetailListByMainId(@RequestParam(name = "id", required = true) String id) {
        List<CalibrationOrderDetail> calibrationOrderDetailList = calibrationOrderDetailService.selectByMainId(id);
        return Result.OK(calibrationOrderDetailList);
    }

    /**
     * 检定附件报告建立关系
     *
     * @param sysUploadList
     * @return
     */
    @AutoLog(value = "检定附件报告建立关系")
    @ApiOperation(value = "检定附件报告建立关系", notes = "检定附件报告建立关系")
    @PostMapping(value = "/addAttachmentRelation")
    public Result<String> addAttachmentRelation(@RequestBody List<SysUpload> sysUploadList) {
        // 附件上传列表是否为空
        if (sysUploadList != null) {
            if (CollectionUtils.isNotEmpty(sysUploadList)) {
                List<SysUploadRela> sysUploadRelaList = new ArrayList<>();
                sysUploadList.forEach(sul -> {
                    SysUploadRela sysUploadRela = new SysUploadRela();
                    sysUploadRela.setBusId(sul.getBusinessAssociationId());
                    sysUploadRela.setBusType("calibration_order_photo");
                    sysUploadRela.setUploadId(sul.getId());
                    sysUploadRelaList.add(sysUploadRela);
                });
                // 上传文件与业务数据关系
                sysBaseApi.saveOrUpdateBatchUploadRela(sysUploadRelaList);
                // 保存判定结果
                sysBaseApi.updateBatchUploadById(sysUploadList);
                // 上传文件与业务数据关系
//                uploadRelaService.saveBatch(sysUploadRelaList);
//                // 保存判定结果
//                uploadService.updateBatchById(sysUploadList);
            }
        }
        return Result.OK("上传成功");
    }

    /**
     * 导出excel
     *
     * @param request
     * @param calibrationOrder
     */
    //@RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, CalibrationOrder calibrationOrder) {
        // Step.1 组装查询条件查询数据
        QueryWrapper<CalibrationOrder> queryWrapper = QueryGenerator.initQueryWrapper(calibrationOrder, request.getParameterMap());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        //配置选中数据查询条件
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            queryWrapper.in("id", selectionList);
        }
        //Step.2 获取导出数据
        List<CalibrationOrder> calibrationOrderList = calibrationOrderService.list(queryWrapper);

        // Step.3 组装pageList
        List<CalibrationOrderPage> pageList = new ArrayList<CalibrationOrderPage>();
        for (CalibrationOrder main : calibrationOrderList) {
            CalibrationOrderPage vo = new CalibrationOrderPage();
            BeanUtils.copyProperties(main, vo);
            List<CalibrationOrderDetail> calibrationOrderDetailList = calibrationOrderDetailService.selectByMainId(main.getId());
//            vo.setCalibrationOrderDetailList(calibrationOrderDetailList);
            pageList.add(vo);
        }

        // Step.4 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        mv.addObject(NormalExcelConstants.FILE_NAME, "检定工单列表");
        mv.addObject(NormalExcelConstants.CLASS, CalibrationOrderPage.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("检定工单数据", "导出人:" + sysUser.getRealname(), "检定工单"));
        mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
        return mv;
    }

    /**
     * 通过excel导入数据
     *
     * @param request
     * @param response
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            // 获取上传文件对象
            MultipartFile file = entity.getValue();
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<CalibrationOrderPage> list = ExcelImportUtil.importExcel(file.getInputStream(), CalibrationOrderPage.class, params);
                for (CalibrationOrderPage page : list) {
                    CalibrationOrder po = new CalibrationOrder();
                    BeanUtils.copyProperties(page, po);
//                    calibrationOrderService.saveMain(po, page.getCalibrationOrderDetailList());
                }
                return Result.OK("文件导入成功！数据行数:" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.OK("文件导入失败！");
    }

    // qsw 2023-7-18======================================================================================================================

    /**
     * 分页列表查询
     *
     */
    @GetMapping(value = "/listNew")
    public Result<IPage<CalibrationOrder>> queryPageListNew(CalibrationOrder calibrationOrder,
                                                    @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                                    @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                                    HttpServletRequest req) {
        QueryWrapper<CalibrationOrder> queryWrapper = QueryGenerator.initQueryWrapper(calibrationOrder, req.getParameterMap());
        Page<CalibrationOrder> page = new Page<CalibrationOrder>(pageNo, pageSize);
        IPage<CalibrationOrder> pageList = calibrationOrderService.page(page, queryWrapper);
        for (CalibrationOrder record : pageList.getRecords()) {
            String id = record.getId();
            String status = record.getStatus();
            String managementMode = record.getManagementMode();
            String equipmentId = record.getEquipmentId();
            Equipment equipment = equipmentService.getById(equipmentId);
            if(equipment != null){
                record.setEquipmentNum(equipment.getNum());
                record.setEquipmentName(equipment.getName());
                record.setEquipmentModel(equipment.getModel());
                record.setEquipmentSpecification(equipment.getSpecification());
            }
            List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(equipmentId);
            record.setPrecisionParameterList(precisionParameterList);
            if("4".equals(status)){
                if("data".equals(managementMode)){
                    List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.lambdaQuery()
                            .eq(CalibrationOrderDetail::getCalibrationOrderId, id)
                            .eq(CalibrationOrderDetail::getJudgmentResult, "fail")
                            .eq(CalibrationOrderDetail::getDelFlag,"0").list();
                    if(calibrationOrderDetails.size()>0){
                        record.setCalibrationResult("异常");
                    }else{
                        record.setCalibrationResult("正常");
                    }
                }else{
                    List<CalibrationOrderReport> calibrationOrderReports = calibrationOrderReportService.lambdaQuery()
                            .eq(CalibrationOrderReport::getCalibrationOrderId, id)
                            .eq(CalibrationOrderReport::getJudgmentResult, "fail")
                            .eq(CalibrationOrderReport::getDelFlag, "0").list();
                    if(calibrationOrderReports.size()>0){
                        record.setCalibrationResult("异常");
                    }else{
                        record.setCalibrationResult("正常");
                    }
                }
            }
        }
        return Result.OK(pageList);
    }
    /**
     * 编辑
     * qsw 2023-7-18
     */
    @RequestMapping(value = "/editNew", method = {RequestMethod.PUT, RequestMethod.POST})
    public Result<String> editNew(@RequestBody CalibrationOrder calibrationOrder) {
        calibrationOrderService.updateById(calibrationOrder);
        List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.lambdaQuery().eq(CalibrationOrderDetail::getCalibrationOrderId, calibrationOrder.getId()).eq(CalibrationOrderDetail::getDelFlag, "0").list();
        for (CalibrationOrderDetail calibrationOrderDetail : calibrationOrderDetails) {
            calibrationOrderDetailService.removeById(calibrationOrderDetail);
        }
        List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(calibrationOrder.getEquipmentId());
        CalibrationOrderDetail calibrationOrderDetail = null;
        for (Map<String, Object> map : precisionParameterList) {
            calibrationOrderDetail = new CalibrationOrderDetail();
            calibrationOrderDetail.setCalibrationOrderId(calibrationOrder.getId());
            calibrationOrderDetail.setEquipmentPrecisionParametersId((String)map.get("id"));
            calibrationOrderDetail.setPrecisionParametersId((String)map.get("precisionParametersId"));
            calibrationOrderDetailService.save(calibrationOrderDetail);
        }
        return Result.OK("编辑成功!");
    }

    /**
     * 手动创建检定工单
     *  qsw 2023-7-18
     */
    @PostMapping(value = "/addNew")
    @Transactional(rollbackFor = {Exception.class})
    public Result<String> addNew(@RequestBody CalibrationOrder calibrationOrder) {
        calibrationOrder.setStatus("1");
        calibrationOrderService.save(calibrationOrder);
        List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(calibrationOrder.getEquipmentId());
        CalibrationOrderDetail calibrationOrderDetail = null;
        for (Map<String, Object> map : precisionParameterList) {
            calibrationOrderDetail = new CalibrationOrderDetail();
            calibrationOrderDetail.setCalibrationOrderId(calibrationOrder.getId());
            calibrationOrderDetail.setEquipmentPrecisionParametersId((String)map.get("id"));
            calibrationOrderDetail.setPrecisionParametersId((String)map.get("precisionParametersId"));
            calibrationOrderDetailService.save(calibrationOrderDetail);
        }
        return Result.OK("添加成功！");
    }

    /**
     * 设备检定工单 创建时通过设备获取设备精度参数
     * qsw 2023-7-18
     */
    @GetMapping("getPrecisionParameterList")
    public Result<?> getPrecisionParameterList(@Param("equipmentId") String equipmentId) {
        List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(equipmentId);
        return Result.ok(precisionParameterList);
    }

    /**
     *
     */
    @RequestMapping(value = "/editStatus", method = {RequestMethod.PUT, RequestMethod.POST})
    public Result<String> editStatus(@RequestBody CalibrationOrder calibrationOrder) {
        calibrationOrder.setIssueTime(new Date());
        boolean b = calibrationOrderService.updateById(calibrationOrder);
        if (b) {
            return Result.OK("下发成功!");
        } else {
            return Result.error("下发失败!");
        }
    }

    @RequestMapping(value = "/report", method = {RequestMethod.PUT, RequestMethod.POST})
    public Result<String> report(@RequestBody CalibrationOrder calibrationOrder) {
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = sysUser.getId();
        calibrationOrder.setCalibrationUserId(userId);
        calibrationOrder.setCalibrationTime(new Date());
        boolean b = calibrationOrderService.updateById(calibrationOrder);
        if (!b) {
            return Result.error("报工失败!");
        } else {
            return Result.ok("报工成功!");
        }
    }

    /**
     *   通过id删除
     */
    @DeleteMapping(value = "/deleteNew")
    public Result<String> deleteNew(@RequestParam(name="id",required=true) String id) {

        List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.lambdaQuery().eq(CalibrationOrderDetail::getCalibrationOrderId, id).eq(CalibrationOrderDetail::getDelFlag, "0").list();
        for (CalibrationOrderDetail calibrationOrderDetail : calibrationOrderDetails) {
            calibrationOrderDetailService.removeById(calibrationOrderDetail);
        }
        //删除文件管理与业务数据关系
        List<CalibrationOrderReport> calibrationOrderReports = calibrationOrderReportService.lambdaQuery().eq(CalibrationOrderReport::getCalibrationOrderId, id).eq(CalibrationOrderReport::getDelFlag, "0").list();
        for (CalibrationOrderReport calibrationOrderReport : calibrationOrderReports) {
            String calibrationOrderReportId = calibrationOrderReport.getId();
            List<SysUploadRela> sysUploadRelas = sysBaseApi.listByBusIdAndBusType(calibrationOrderReportId, null);
            for (SysUploadRela sysUploadRela : sysUploadRelas) {
                String uploadId = sysUploadRela.getUploadId();
                sysBaseApi.removeUploadById(uploadId);
                sysBaseApi.removeUploadRelaById(sysUploadRela.getId());
            }
            calibrationOrderReportService.removeById(calibrationOrderReportId);
        }
        calibrationOrderService.removeById(id);
        return Result.OK("删除成功!");
    }
}