rongxing-java/src/main/java/com/gaotao/modules/schedule/controller/ScheduleController.java

package com.gaotao.modules.schedule.controller;

import com.gaotao.common.utils.R;
import com.gaotao.common.annotation.RepeatSubmit;
import com.gaotao.modules.schedule.data.*;
import com.gaotao.modules.schedule.data.dto.ScheduleDateShifDto;
import com.gaotao.modules.schedule.data.dto.WorkbenchPostinspection;
import com.gaotao.modules.schedule.service.ScheduleService;
import com.gaotao.modules.shopOrder.entity.OperatorData;
import com.gaotao.modules.shopOrder.entity.ShopOrderData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.text.ParseException;
import java.util.List;
import java.util.Map;

/**
 * 生产订单排产
 * @author LR
 * @date 2021/10/20 11:04
 **/
@RestController
@RequestMapping(value = "/schedule")
public class ScheduleController {

    @Autowired
    private ScheduleService scheduleService;
    /**
     * TODO 获取排产班次的休息时间
     * @author LR
     * @date 2021/10/25 14:04
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @PostMapping(value = "getResourceRestList")
    public R getResourceRestList(@RequestBody SearchScheduleData inData){
        List<ShiftInfoData> resultList = scheduleService.getResourceRestList(inData);
        //获取当前的calendarId
        Map<String, Object>  calendarMap = scheduleService.getCalendarIdByResourceId(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("calendarRow", calendarMap)
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 按照条件查询工单的数据
     * @author LR
     * @date 2021/10/25 14:23
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getShopOrderList")
    public R getShopOrderList(@RequestBody SearchScheduleData inData){
        List<ShopOrderOutData> resultList = scheduleService.getShopOrderList(inData);
       // Float requireScheduleTime = scheduleService.getRequireScheduleTime(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                //.put("requireScheduleTime", requireScheduleTime)
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询派工单的数据
     * @author LR
     * @date 2021/10/25 16:07
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getOrderScheduleList")
    public R getOrderScheduleList(@RequestBody SearchScheduleData inData){
        List<ScheduleData> resultList = scheduleService.getOrderScheduleList(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询-待生产工单
     * @author LR
     * @date 2021/10/28 16:46
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getProduceScheduleData")
    public R getProduceScheduleData(@RequestBody SearchScheduleData inData){
        List<ScheduleData> resultList = scheduleService.getProduceScheduleData(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 获取操作员的列表信息
     * @author LR
     * @date 2021/11/4 11:41
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getOperatorList")
    public R getOperatorList(@RequestBody OperatorData inData){
        List<OperatorData> resultList = scheduleService.getOperatorList(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 获取操作员信息
     * @author LR
     * @date 2021/11/4 11:37
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getOperatorData")
    public R getOperatorData(@RequestBody OperatorOutData inData){
        OperatorOutData result = scheduleService.getOperatorData(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 按照派工单号查询派工单的数据
     * @author LR
     * @date 2021/11/8 14:23
     * @param seqNo
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getScheduleDataBySeqNo")
    public R getScheduleDataBySeqNo(@RequestBody String seqNo){
        ScheduleData result = scheduleService.getScheduleDataBySeqNo(seqNo);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 获取当前的上机卷信息
     * @author LR
     * @date 2021/11/9 16:02
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getCurrentRollOpsBySeqNo")
    public R getCurrentRollOpsBySeqNo(@RequestBody BaseRollData inData){
        SfdcRollOpsData result = scheduleService.getCurrentRollOpsBySeqNo(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 查询派工单的时间记录
     * @author LR
     * @date 2021/11/10 15:13
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcTimeByCon")
    public R getSfdcTimeByCon(@RequestBody SearchScheduleData inData){
        List<SfdcTimeData> resultList = scheduleService.getSfdcTimeByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询工单的工具信息
     * @author LR
     * @date 2021/11/11 14:05
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getOrderToolByCon")
    public R getOrderToolByCon(@RequestBody SearchScheduleData inData){
        List<ToolInstanceData> resultList = scheduleService.getOrderToolByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询派工单工具的数据
     * @author LR
     * @date 2021/11/10 16:29
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcToolByCon")
    public R getSfdcToolByCon(@RequestBody SearchScheduleData inData){
        List<SfdcToolData> resultList = scheduleService.getSfdcToolByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 获取工单的BOM信息
     * @author LR
     * @date 2021/11/11 17:20
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getOrderBomByCon")
    public R getOrderBomByCon(@RequestBody SearchScheduleData inData){
        List<OrderBomData> resultList = scheduleService.getOrderBomByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询派工单材料上机的数据
     * @author LR
     * @date 2021/11/10 16:56
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcMaterialByCon")
    public R getSfdcMaterialByCon(@RequestBody SearchScheduleData inData){
        List<SfdcMaterialData> resultList = scheduleService.getSfdcMaterialByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询上机卷的记录数据
     * @author LR
     * @date 2021/11/9 16:24
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcRollOpsByCon")
    public R getSfdcRollOpsByCon(@RequestBody SearchScheduleData inData){
        List<SfdcRollOpsData> resultList = scheduleService.getSfdcRollOpsByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询派工单的不良卷信息
     * @author LR
     * @date 2021/11/10 17:18
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcDefectByCon")
    public R getSfdcDefectByCon(@RequestBody SearchScheduleData inData){
        List<SfdcDefectData> resultList = scheduleService.getSfdcDefectByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询下机卷数据
     * @author LR
     * @date 2021/11/10 17:58
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcRollByCon")
    public R getSfdcRollByCon(@RequestBody SearchScheduleData inData){
        List<SfdcRollData> resultList = scheduleService.getSfdcRollByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 获取卷的报工数据
     * @author LR
     * @date 2021/11/25 18:02
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcDataByCon")
    public R getSfdcDataByCon(@RequestBody SearchScheduleData inData){
        List<SfdcData> resultList = scheduleService.getSfdcDataByCon(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 查询sfdc_rolls表中的汇总报工数据
     * @author LR
     * @date 2021/11/26 16:13
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcRollReportedQty")
    public R getSfdcRollReportedQty(@RequestBody SearchScheduleData inData){
        Float reportedQty = scheduleService.getSfdcRollReportedQty(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("reportedQty", reportedQty);
    }

    /**
     * TODO 查询当前是否存在报工的数据
     * @author LR
     * @date 2021/11/26 16:14
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "countSfdcRollByRollNo")
    public R countSfdcRollByRollNo(@RequestBody SearchScheduleData inData){
        Integer countNums = scheduleService.countSfdcRollByRollNo(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("countNums", countNums);
    }

    /**
     * TODO 查询报告的不良数据
     * @author LR
     * @date 2021/11/26 16:17
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcDefectDefectedQty")
    public R getSfdcDefectDefectedQty(@RequestBody SearchScheduleData inData){
        Float defectedQty = scheduleService.getSfdcDefectDefectedQty(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("defectedQty", defectedQty);
    }

    /**
     * TODO 查询sfdc_time的时间汇总数据
     * @author LR
     * @date 2021/11/26 16:20
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "countSfdcTimeQty")
    public R countSfdcTimeQty(@RequestBody SearchScheduleData inData){
       Map<String, Object> result = scheduleService.countSfdcTimeQty(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 查询sfdc_time的最大和最小以及一些汇总数据
     * @author LR
     * @date 2021/11/26 16:21
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcTimeMaxAndMinTime")
    public R getSfdcTimeMaxAndMinTime(@RequestBody SearchScheduleData inData){
        Map<String, Object> result = scheduleService.getSfdcTimeMaxAndMinTime(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 获取上机卷的报工数据
     * @author LR
     * @date 2021/11/29 17:11
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcRollOpsReportedQty")
    public R getSfdcRollOpsReportedQty(@RequestBody SearchScheduleData inData){
        Map<String, Object> result = scheduleService.getSfdcRollOpsReportedQty(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 获取当前的报工汇总信息
     * @author LR
     * @date 2021/11/30 13:31
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getCurrentRollReportedQty")
    public R getCurrentRollReportedQty(@RequestBody SearchScheduleData inData){
        Map<String, Object> result = scheduleService.getCurrentRollReportedQty(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 获取派工单的班次信息
     * @author LR
     * @date 2021/12/1 10:08
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getScheduleShiftData")
    public R getScheduleShiftData(@RequestBody SearchScheduleData inData) throws ParseException {
        Map<String, Object> result = scheduleService.getScheduleShiftData(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 获取sfdc表的时间汇总
     * @author LR
     * @date 2021/12/1 15:29
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcTimeData")
    public R getSfdcTimeData(@RequestBody SearchScheduleData inData){
        Map<String, Object> result = scheduleService.getSfdcTimeData(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 获取sfdc的报工数据以及时间的数据
     * @author LR
     * @date 2021/12/7 9:18
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcReportedData")
    public R getSfdcReportedData(@RequestBody SearchScheduleData inData){
        SfdcData result = scheduleService.getSfdcReportedData(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

    /**
     * TODO 查询当前卷的材料上机记录--在线的
     * @author LR
     * @date 2021/12/7 10:21
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcMaterialByRollNo")
    public R getSfdcMaterialByRollNo(@RequestBody SearchScheduleData inData){
        List<SfdcMaterialData> resultList = scheduleService.getSfdcMaterialByRollNo(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * TODO 刷新页面的按钮的控制
     * @author LR
     * @date 2021/12/10 16:41
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "refreshWorkPlatformButtons")
    public R refreshWorkPlatformButtons(@RequestBody SearchScheduleData inData){
       Map<String, Object> resultMap = scheduleService.refreshWorkPlatformButtons(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }

    /**
     * TODO 检查工作台的各种按钮
     * @author LR
     * @date 2021/12/10 18:08
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkScheduleButton")
    public R checkScheduleButton(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkScheduleButton(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }

    /**
     * TODO 检查创建新卷的功能
     * @author LR
     * @date 2021/12/13 9:20
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkCreateNewSfdcRoll")
    public R checkCreateNewSfdcRoll(@RequestBody SearchScheduleData inData){
        scheduleService.checkCreateNewSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 创建新卷的功能
     * @author LR
     * @date 2021/12/13 9:20
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "createNewRoll")
    @RepeatSubmit
    public R createNewRoll(@RequestBody SearchScheduleData inData){
        scheduleService.createNewRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 开始调机
     * @author LR
     * @date 2021/12/27 14:54
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "startTuning")
    public R startTuning(@RequestBody SearchScheduleData inData){
        scheduleService.startTuning(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 检验停机代码
     * @author LR
     * @date 2021/12/27 11:42
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkDownTimeCode")
    public R checkDownTimeCode(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkDownTimeCode(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * TODO 报告停机代码
     * @author LR
     * @date 2021/12/27 17:16
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "reportDownTime")
    public R reportDownTime(@RequestBody SearchScheduleData inData){
      scheduleService.reportDownTime(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 查询派工单的不良记录
     * @author LR
     * @date 2021/12/28 15:09
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getScheduleDefectHist")
    public R getScheduleDefectHist(@RequestBody SearchScheduleData inData){
        List<SfdcDefectData> resultList = scheduleService.getScheduleDefectHist(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList);
    }

    /**
     * TODO 检查不良代码
     * @author LR
     * @date 2021/12/28 11:31
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkDefectCode")
    public R checkDefectCode(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkDefectCode(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }


    /**
     * TODO 报告不良代码
     * @author LR
     * @date 2021/12/28 16:47
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "reportDefectCode")
    public R reportDefectCode(@RequestBody SearchScheduleData inData){
        scheduleService.reportDefectCode(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 检查工具实例的编码
     * @author LR
     * @date 2021/12/28 18:33
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkToolInstanceId")
    public R checkToolInstanceId(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkToolInstanceId(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * TODO 添加工具实例
     * @author LR
     * @date 2021/12/28 18:45
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "addToolInstanceId")
    public R addToolInstanceId(@RequestBody SearchScheduleData inData){
        scheduleService.addToolInstanceId(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 根据工单和物料自动获取bom行数据
     * @DateTime  2021/12/20 10:59
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getBomItemNosByPartNo")
    public R getBomItemNosByPartNo(@RequestBody SearchScheduleData inData){
        List<Map<String, Object>> resultList = scheduleService.getBomItemNosByPartNo(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList);
    }

    /**
     * TODO 检查是否可以上当前的材料卷
     * @author LR
     * @date 2021/12/30 11:48
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkFeedingMaterialRoll")
    public R checkMaterialRoll(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkFeedingMaterialRoll(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * @Author LR
     * @Description 保存材料上机的记录数据
     * @DateTime  2021/12/20 16:34
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "feedingMaterialRoll")
    public R feedingMaterialRoll(@RequestBody SearchScheduleData inData){
        scheduleService.feedingMaterialRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 检查是否可以开始生产
     * @author LR
     * @date 2021/12/31 11:22
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkStartProduce")
    public R checkStartProduce(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkStartProduce(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * TODO 开始生产的业务
     * @author LR
     * @date 2022/1/6 17:24
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "startProduce")
    public R startProduce(@RequestBody SearchScheduleData inData){
        scheduleService.startProduce(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 结束调机和开始生产
     * @author LR
     * @date 2022/1/12 14:01
     * @param inMap
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "endTuningAndStartProduce")
    public R endTuningAndStartProduce(@RequestBody Map<String, Object> inMap){
        scheduleService.endTuningAndStartProduce(inMap);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 工具的使用的数量
     * @author LR
     * @date 2022/1/18 14:10
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "countToolUsedQty")
    public R countToolUsedQty(@RequestBody SearchScheduleData inData){
       Float usedQty = scheduleService.countToolUsedQty(inData);
        return R.ok()
                .put("code", 200)
                .put("usedQty", usedQty)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 刀模切换检查
     * @author LR
     * @date 2022/1/19 10:32
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkConnectToolInstanceId")
    public R checkConnectToolInstanceId(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkConnectToolInstanceId(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * TODO换刀操作
     * @author LR
     * @date 2022/1/19 14:46
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "connectToolInstanceId")
    public R connectToolInstanceId(@RequestBody SearchScheduleData inData){
        scheduleService.connectToolInstanceId(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 材料切换检查
     * @author LR
     * @date 2022/1/19 10:32
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkConnectMaterialRoll")
    public R checkConnectMaterialRoll(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.checkConnectMaterialRoll(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * TODO 换料操作
     * @author LR
     * @date 2022/1/19 14:46
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "connectMaterialRoll")
    public R connectMaterialRoll(@RequestBody SearchScheduleData inData){
        scheduleService.connectMaterialRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR 结束卷校验--非FQC和最后一道
     * @Description
     * @DateTime  2022/1/25 13:30
     * @Param [inMap]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkFinishRollWithNoFqc")
    public R checkFinishRollWithNoFqc(@RequestBody Map<String, Object> inMap){
        Map<String, Object> resultMap = scheduleService.checkFinishRollWithNoFqc(inMap);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * TODO 结束卷操作--非FQC和最后一道
     * @author LR
     * @date 2022/1/19 14:46
     * @param inMap
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "finishRollWithNoFqc")
    public R finishRollWithNoFqc(@RequestBody Map<String, Object> inMap){
        String rollNo = scheduleService.finishRollWithNoFqc(inMap);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("rollNo", rollNo)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 获取关单页面的参数数据
     * @DateTime  2022/2/4 11:07
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getFinishSchedulePageData")
    public R getFinishSchedulePageData(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultMap = scheduleService.getFinishSchedulePageData(inData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * @Author LR
     * @Description 获取派工单的时间记录的数据
     * @DateTime  2022/2/4 15:28
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcTimeHistBySeqNo")
    public R getSfdcTimeHistBySeqNo(@RequestBody SearchScheduleData inData) {
        List<SfdcTimeData> resultList = scheduleService.getSfdcTimeHistBySeqNo(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList);
    }

    /**
     * @Author LR
     * @Description 获取派工单的工具记录的数据
     * @DateTime  2022/2/4 15:29
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcToolHistBySeqNo")
    public R getSfdcToolHistBySeqNo(@RequestBody SearchScheduleData inData) {
        List<SfdcToolData> resultList = scheduleService.getSfdcToolHistBySeqNo(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList);
    }

    /**
     * @Author LR
     * @Description 获取派工单的材料记录
     * @DateTime  2022/2/4 15:30
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSfdcMaterialHistBySeqNo")
    public R getSfdcMaterialHistBySeqNo(@RequestBody SearchScheduleData inData) {
        List<SfdcMaterialData> resultList = scheduleService.getSfdcMaterialHistBySeqNo(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList);
    }

    /**
     * @Author LR
     * @Description 派工单结束检查
     * @DateTime  2022/2/8 9:56
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkFinishScheduleWithNoFqc")
    public R checkFinishScheduleWithNoFqc(@RequestBody SearchScheduleData inData) {
      Map<String, Object> resultMap = scheduleService.checkFinishScheduleWithNoFqc(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }
    /**
     * @Author LR
     * @Description 结束非FQC的派工单
     * @DateTime  2022/2/8 11:24
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "finishScheduleWithNoFqc")
    public R finishScheduleWithNoFqc(@RequestBody SearchScheduleData inData) {
        scheduleService.finishScheduleWithNoFqc(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 查询校验是否可以下料功能
     * @DateTime  2022/2/15 16:40
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkCuttingMaterial")
    public R checkCuttingMaterial(@RequestBody SearchScheduleData inData) {
        Map<String, Object> resultMap = scheduleService.checkCuttingMaterial(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }

    /**
     * @Author LR
     * @Description 处理材料下料功能
     * @DateTime  2022/2/15 17:12
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "processCuttingMaterialRoll")
    public R processCuttingMaterialRoll(@RequestBody SearchScheduleData inData) {
        List<Map<String, Object>> printList = scheduleService.processCuttingMaterialRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("printList", printList)
                .put("msg", "操作成功!");
    }

    /**
     * TODO  重新打开当前下架卷的数据
     * @author LR
     * @date 2022/2/16 14:24
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "reopenSfdcRolls")
    public R reopenSfdcRolls(@RequestBody SearchScheduleData inData) {
        scheduleService.reopenSfdcRolls(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 删除sfdcRolls卷的操作
     * @author LR
     * @date 2022/2/16 16:07
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "deleteSfdcRolls")
    public R deleteSfdcRolls(@RequestBody SearchScheduleData inData) {
        scheduleService.deleteSfdcRolls(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * TODO  校验切换卷是否可以进行
     * @author LR
     * @date 2022/2/16 17:19
     * @param inData
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkSwitchSfdcRoll")
    public R checkSwitchSfdcRoll(@RequestBody SearchScheduleData inData) {
        Map<String, Object> resultMap = scheduleService.checkSwitchSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }

    /**
     * TODO  切换卷操作
     * @author LR
     * @date 2022/2/16 18:25
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "switchSfdcRoll")
    public R switchSfdcRoll(@RequestBody SearchScheduleData inData) {
        scheduleService.switchSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 检查是否可以创建分卷
     * @DateTime  2022/2/17 11:45
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkCreateSplitSfdcRoll")
    public R checkCreateSplitSfdcRoll(@RequestBody SearchScheduleData inData) {
        Map<String, Object> resultMap = scheduleService.checkCreateSplitSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }

   /**
    * @Author LR
    * @Description 执行创建分卷的业务逻辑
    * @DateTime  2022/2/17 11:45
    * @Param [inData]
    * @return com.gaotao.common.utils.R
    **/
    @RequestMapping(value = "createSplitSfdcRoll")
    public R createSplitSfdcRoll(@RequestBody SearchScheduleData inData) {
        List<Map<String, Object>> printList = scheduleService.createSplitSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("printList", printList)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 查询合并卷页面的参数
     * @DateTime  2022/2/17 16:20
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getMergeRollPageData")
    public R getMergeRollPageData(@RequestBody SearchScheduleData inData){
        Map<String, Object> resultRow = scheduleService.getMergeRollPageData(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", resultRow);
    }

    /**
     * @Author LR
     * @Description 处理结束工具使用的方法
     * @DateTime  2022/2/18 9:53
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "processFinishTool")
    public R processFinishTool(@RequestBody SearchScheduleData inData){
        scheduleService.processFinishTool(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 材料卷结束使用 且没有剩余
     * @DateTime  2022/2/18 10:50
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "processFinishMaterialWithNoRemainder")
    public R processFinishMaterialWithNoRemainder(@RequestBody SearchScheduleData inData){
        scheduleService.processFinishMaterialWithNoRemainder(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }


    /**
     * @Author LR
     * @Description 产量报告  --检查报告一部分卷数量
     * @DateTime  2022/2/18 17:31
     * @Param [inMap]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkFinishPartRollWithNoFqc")
    public R checkFinishPartRollWithNoFqc(@RequestBody Map<String, Object> inMap){
        scheduleService.checkFinishPartRollWithNoFqc(inMap);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 产量报告  --提前报告一部分卷数量
     * @DateTime  2022/2/18 17:31
     * @Param [inMap]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "finishPartRollWithNoFqc")
    public R finishPartRollWithNoFqc(@RequestBody Map<String, Object> inMap){
        scheduleService.finishPartRollWithNoFqc(inMap);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 校验是否可以合并卷
     * @DateTime  2022/2/20 16:24
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkMergeSfdcRoll")
    public R checkMergeSfdcRoll(@RequestBody SearchScheduleData inData) {
        Map<String, Object> resultMap = scheduleService.checkMergeSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }

    /**
     * @Author LR
     * @Description 合并sfdc卷数据
     * @DateTime  2022/2/20 16:37
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "processMergeSfdcRoll")
    public R processMergeSfdcRoll(@RequestBody SearchScheduleData inData){
        String rollNo = scheduleService.processMergeSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("rollNo", rollNo)
                .put("msg", "操作成功!");
    }

    /**
     * TODO 特殊权限之班次选择数据查询
     * @author LR
     * @date 2022/3/18 11:17
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getScheduleShiftWithSelect")
    public R getScheduleShiftWithSelect(@RequestBody SearchScheduleData inData) throws ParseException {
       List< Map<String, Object>> resultList = scheduleService.getScheduleShiftWithSelect(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }


/*---------------------------------------------------------- sxm其它报工 --------------------------------------------------------*/

    /**
     * @Author sxm
     * @Description 其它报工切换卷
     * @Date 2022/3/7 13:12
     * @Param inData
     * @return  Map<String, Object>
     **/
    @PostMapping(value = "otherCheckSwitchSfdcRoll")
    public R otherCheckSwitchSfdcRoll(@RequestBody SearchScheduleData inData) {
        Map<String, Object> resultMap = scheduleService.otherCheckSwitchSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("resultMap", resultMap);
    }

    /**
     * @Author sxm
     * @Description 其它报工切换卷执行
     * @Date 2022/3/7 13:55
     * @Param inData
     * @return
     **/
    @PostMapping(value = "otherSwitchSfdcRoll")
    public R otherSwitchSfdcRoll(@RequestBody SearchScheduleData inData) {
        scheduleService.otherSwitchSfdcRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

   /**
    * @Author sxm
    * @Description 检查是否可以创建分卷
    * @Date 2022/3/17 11:11
    * @Param
    * @return
    **/
    @PostMapping(value = "otherCheckCreateSplitSfdcRoll")
    public R otherCheckCreateSplitSfdcRoll(@RequestBody SearchScheduleData inData) {
        scheduleService.otherCheckCreateSplitSfdcRoll(inData);
        return R.ok("检验通过!");
    }

    /**
     * @Author sxm
     * @Description 执行创建分卷的业务逻辑
     * @Date 2022/3/7 17:59
     * @Param inData
     * @return
     **/
    @PostMapping(value = "otherCreateSplitSfdcRoll")
    public R otherCreateSplitSfdcRoll(@RequestBody SearchScheduleData inData) {
        String rollNos = scheduleService.otherCreateSplitSfdcRoll(inData);
        return R.ok("操作成功")
                .put("code", 200).put("rollNos",rollNos);
    }

    /**
     * @Author sxm
     * @Description 校验不良代码
     * @Date 2022/3/8 10:00
     * @Param inData
     * @return
     **/
    @PostMapping(value = "checkSfdcDefect")
    public R checkSfdcDefect(@RequestBody SfdcDefectData inData){
        Map<String,Object> map = scheduleService.checkSfdcDefect(inData);
        return R.ok().put("map",map);
    }

    /**
     * @Author sxm
     * @Description 保存不良
     * @Date 2022/3/8 10:00
     * @Param inData
     * @return
     **/
    @PostMapping(value = "saveSfdcDefect")
    public R saveSfdcDefect(@RequestBody SfdcDefectData inData){
        scheduleService.saveSfdcDefect(inData);
        return R.ok("保存成功");
    }

    /**
     * @Author sxm
     * @Description 批量保存不良
     * @Date 2022/3/8 10:00
     * @Param List<SfdcDefectData>
     * @return
     **/
    @PostMapping(value = "saveSfdcDefectList")
    public R saveSfdcDefectList(@RequestBody List<SfdcDefectData> inData){
        scheduleService.saveSfdcDefectList(inData);
        return R.ok("保存成功");
    }

    /**
     * @Author sxm
     * @Description 获取fqc 送检卷
     * @Date 2022/3/8 16:05
     * @Param
     * @return
     **/
    @PostMapping(value = "searchFqcSfdcRolls")
    public R searchFqcSfdcRolls(@RequestBody SfdcRollData inData){
        List<SfdcRollData> resultList = scheduleService.searchFqcSfdcRolls(inData);
        return R.ok().put("list",resultList);
    }

    /**
     * @Author sxm
     * @Description 获取排产日期，班次
     * @Date 2022/3/8 17:23
     * @Param
     * @return
     **/
    @PostMapping(value = "getScheduleDateShift")
    public R getScheduleDateShift(@RequestBody ScheduleDateShifDto dto){
        Map<String,Object>  map= scheduleService.getScheduleDateShif(dto);
        return R.ok().put("map",map);
    }

    /**
     * @Author sxm
     * @Description 批量直接送检
     * @Date 2022/3/8 17:54
     * @Param rollDatas
     * @return
     **/
    @PostMapping("workbenchPostinspection")
    public R workbenchPostinspection(@RequestBody List<WorkbenchPostinspection> rollDatas){
        scheduleService.workbenchPostinspection(rollDatas);
        return R.ok();
    }

    /**
     * @Author sxm
     * @Description 返工重检下机卷列表
     * @Date 2022/3/9 11:48
     * @Param SearchScheduleData
     * @return
     **/
    @RequestMapping(value = "getReworkSfdcRollByCon")
    public R getReworkSfdcRollByCon(@RequestBody SearchScheduleData inData){
        List<SfdcRollData> resultList = scheduleService.getReworkSfdcRollByCon(inData);
        return R.ok().put("code", 200)
                .put("rows", resultList)
                .put("total", resultList.size());
    }

   /**
    * @Author sxm
    * @Description 删除卷
    * @Date 2022/3/15 16:20
    * @Param
    * @return
    **/
    @RequestMapping(value = "switchrollReverse")
    public R switchrollReverse(@RequestBody SearchScheduleData inData){
         scheduleService.switchrollReverse(inData);
        return R.ok("验证通过");
    }

    /**
     * @Author sxm
     * @Description 报工校验
     * @Date 2022/3/15 16:20
     * @Param
     * @return
     **/
    @RequestMapping(value = "reportCheck")
    public R reportCheck(@RequestBody SearchScheduleData inData){
        scheduleService.reportCheck(inData);
        return R.ok("验证通过");
    }

    /**
     * @Author sxm
     * @Description 获取前道工序
     * @Date 2022/3/17 9:29
     * @Param inData
     * @return
     **/
    @PostMapping(value = "getSORoutingPreviousOperationItemNo")
    public R getSORoutingPreviousOperationItemNo(@RequestBody SearchScheduleData inData){
        int itemNo = scheduleService.getSORoutingPreviousOperationItemNo(inData);
        return R.ok().put("itemNo", itemNo);
    }

   /**
    * @Author sxm
    * @Description 获取用户特殊权限
    * @Date 2022/3/18 9:35
    * @Param inData
    * @return
    **/
    @PostMapping(value = "getUserSpecialSecurity")
    public R getUserSpecialSecurity(@RequestBody SearchScheduleData inData){
        String userSpecialSecurity = scheduleService.getUserSpecialSecurity(inData);
        return R.ok().put("userSpecialSecurity", userSpecialSecurity);
    }

    /**
     * @Author sxm
     * @Description 关闭/打开 生产工单
     * @Date 2022/3/18 10:07
     * @Param inData
     * @return
     **/
    @PostMapping(value = "closeOrOpenProduceOrder")
    public R closeOrOpenProduceOrder(@RequestBody SearchScheduleData inData){
         scheduleService.closeOrOpenProduceOrder(inData);
        return R.ok("操作成功,请刷新数据！");
    }

    /**
     * @Author sxm
     * @Description 暂停/重开生产工单
     * @Date 2022/3/18 10:07
     * @Param inData
     * @return
     **/
    @PostMapping(value = "pauseOrOpenProduceOrder")
    public R pauseOrReopenProduceOrder(@RequestBody SearchScheduleData inData){
        scheduleService.pauseOrReopenProduceOrder(inData);
        return R.ok("操作成功,请刷新数据！");
    }

   /**
    * @Author sxm
    * @Description 确认生产已排料 / 取消生产已排料
    * @Date 2022/3/23 9:33
    * @Param inData
    * @return 
    **/
    @PostMapping(value = "costRollUpProduceOrder")
    public R costRollUpProduceOrder(@RequestBody SearchScheduleData inData){
        scheduleService.costRollUpProduceOrder(inData);
        return R.ok("操作成功,请刷新数据！");
    }

    /**
     * @Author sxm
     * @Description 确认/取消 刀模已发
     * @Date 2022/3/23 10:16
     * @Param inData
     * @return
     **/
    @PostMapping(value = "manualProduceOrder")
    public R manualProduceOrder(@RequestBody SearchScheduleData inData){
        scheduleService.manualProduceOrder(inData);
        return R.ok("操作成功,请刷新数据！");
    }

    /**
     * @Author sxm
     * @Description 印版取消已发
     * @Date 2022/3/24 8:43
     * @Param inData
     * @return
     **/
    @PostMapping(value = "repairSOFlagProduceOrder")
    public R repairSOFlagProduceOrder(@RequestBody SearchScheduleData inData){
        scheduleService.repairSOFlagProduceOrder(inData);
        return R.ok("操作成功,请刷新数据！");
    }

    /**
     * @Author sxm
     * @Description 取消派工单所有操作
     * @Date 2022/3/24 8:43
     * @Param inData
     * @return
     **/
    @PostMapping(value = "workbenchCancelallops")
    public R workbenchCancelallops(@RequestBody SearchScheduleData inData){
        return scheduleService.workbenchCancelallops(inData);
    }

    /**
     * @Author sxm
     * @Description 创建重检派工单
     * @Date 2022/3/24 13:16
     * @Param inData
     * @return
     **/
    @PostMapping(value = "soscheduleNewReinspectjob")
    public R soscheduleNewReinspectjob(@RequestBody SearchScheduleData inData){
        return scheduleService.soscheduleNewReinspectjob(inData);
    }

    /**
     * @Author sxm
     * @Description 换包装校验
     * @Date 2022/3/30 16:14
     * @Param
     * @return
     **/
    @RequestMapping(value = "checkRepackFinishRollWithNoFqc")
    public R checkRepackFinishRollWithNoFqc(@RequestBody Map<String, Object> inMap){
        Map<String, Object> resultMap = scheduleService.checkRepackFinishRollWithNoFqc(inMap);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * @Author sxm
     * @Description 换包装结束卷
     * @Date 2022/3/30 16:26
     * @Param
     * @return
     **/
    @RequestMapping(value = "repackFinishRollWithNoFqc")
    public R repackFinishRollWithNoFqc(@RequestBody Map<String, Object> inMap){
        scheduleService.repackFinishRollWithNoFqc(inMap);
        return R.ok()
                .put("code", 200)
                .put("success", true)
                .put("msg", "操作成功!");
    }


    /**
     * @Author sxm
     * @Description 结束换包装 fqc
     * @Date 2022/3/30 16:30
     * @Param
     * @return
     **/
    @RequestMapping(value = "repackFinishScheduleWithNoFqc")
    public R repackFinishScheduleWithNoFqc(@RequestBody SearchScheduleData inData) {
        scheduleService.repackFinishScheduleWithNoFqc(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * @Author sxm
     * @Description 获取订单类型
     * @Date 2022/3/30 17:37
     * @Param
     * @return
     **/
    @PostMapping("getShopOrderType")
    public R getShopOrderType(@RequestBody SearchScheduleData inData){
        String shopOrderType = scheduleService.getShopOrderType(inData);
        return R.ok()
                .put("data", shopOrderType)
                .put("msg", "操作成功!");
    }

    /**
     * @Author sxm
     * @Description 切换卷校验
     * @Date 2022/4/5 16:05
     * @Param
     * @return
     **/
    @RequestMapping(value = "switchrollRepackCheck")
    public R switchrollRepackCheck(@RequestBody SearchScheduleData scheduleData){
        Map<String, Object> resultMap = scheduleService.switchrollRepackCheck(scheduleData);
        return R.ok()
                .put("resultMap", resultMap);
    }

    /**
     * @Author sxm
     * @Description 换包装 切换卷
     * @Date 2022/3/30 16:30
     * @Param
     * @return
     **/
    @RequestMapping(value = "switchrollRepackAction")
    public R switchrollRepackAction(@RequestBody SearchScheduleData inData) {
        scheduleService.switchrollRepackAction(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }


    /**
     * @Author sxm
     * @Description 换包装创建分卷
     * @Date 2022/4/5 16:54
     * @Param
     * @return
     **/
    @RequestMapping(value = "workbench_createslittingroll_Repack_action")
    public R workbenchCreateslittingrollRepackAction(@RequestBody SearchScheduleData inData) {
        List<Map<String, Object>> printList = scheduleService.workbenchCreateslittingrollRepackAction(inData);
        return R.ok()
                .put("code", 200)
                .put("printList", printList)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 分切订单校验切换卷
     * @DateTime  2022/4/19 9:23
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "checkSplitScheduleSwitchRoll")
    public R checkSplitScheduleSwitchRoll(@RequestBody SearchScheduleData inData) {
        scheduleService.checkSplitScheduleSwitchRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 分切订单切换卷
     * @DateTime  2022/4/20 10:43
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "splitScheduleSwitchRoll")
    public R splitScheduleSwitchRoll(@RequestBody SearchScheduleData inData) {
        scheduleService.splitScheduleSwitchRoll(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!");
    }

    /**
     * @Author LR
     * @Description 获取分切工单的物料行信息
     * @DateTime  2022/4/20 14:53
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSplitOrderParts")
    public R getSplitOrderParts(@RequestBody SearchScheduleData inData){
        List<Map<String, Object>> resultList = scheduleService.getSplitOrderParts(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("rows", resultList)
                .put("total", resultList.size());
    }

    /**
     * @Author LR
     * @Description 获取分切工单上机卷的报工数量
     * @DateTime  2022/4/21 8:47
     * @Param [inData]
     * @return com.gaotao.common.utils.R
     **/
    @RequestMapping(value = "getSplitOrderCurrentRollReportedQty")
    public R getSplitOrderCurrentRollReportedQty(@RequestBody SearchScheduleData inData){
        Map<String, Object> result = scheduleService.getSplitOrderCurrentRollReportedQty(inData);
        return R.ok()
                .put("code", 200)
                .put("msg", "操作成功!")
                .put("row", result);
    }

}