拉取后对应翻译没了，部分代码报错，修改后提交

clll

2023-11-09 a8d31b3d7b6e0d60b8045ace9be49cdfb590696f

拉取后对应翻译没了，部分代码报错，修改后提交

 CanadaMes-ui/src/lang/locales/zh-CN.json

@@ -196,10 +196,8 @@
  "langResetButton": "重置",

  "langCancelButton": "取消",

  "langRegisterSuccessMessage": "注册成功",



  "添加用户成功":"添加用户成功",

  "添加用户成功": "添加用户成功",

  "confirmResetPassword": "确认重置密码为默认值吗？",

  
  "confirm": "确定",

  "cancel": "取消",

  "passwordResetSuccess": "密码已重置为默认值",

@@ -210,67 +208,60 @@
  "addUserSuccess": "添加用户成功",

  "editUserSuccess": "修改用户成功",

  "effective": "有效",

"invalid": "无效",



"addSuccessMessage": "添加成功",

"deleteConfirmMessage": "确定要删除该权限吗？",



"confirmButtonText": "确定",

"cancelButtonText": "取消",

"deleteSuccessMessage": "删除成功",

"deleteCancelledMessage": "已取消删除操作",







  "Enter the glass lD":"输入玻璃id",

  "Infeed barcodid":"手动上片",

  "Enter the order number":"输入订单号",

  "Exit the glass by order number":"按订单出片",

  "Please confirm the glass information":"请确认玻璃信息",

  "Please confirm the Ordering Information":"请确认订单信息",

  "Alarm Information":"报警信息",

  "Cage Details":"理片笼详情",

  "order":"订单",

  "length":"长",

  "width":"宽",

  "Operate":"操作",

  "end task":"完成任务",

  "cancel":"取消",

  "confirm":"确认",

  "number":"数量",

  "Outfeed Barcodid":"出片玻璃id",

  "Infeed Barcodid":"进片玻璃id",

  "The Cage number being used":"笼子",

  "The Slot number being used":"格子",

  "Order Nmuber":"订单编号",

  "List Number":"列表编号",

  "Box Number":"箱子编号",

  "Length and Width":"尺寸",

  "id":"id",

  "content":"内容",

  "timeon":"报警时间",

  "endTime":"结束时间",



  "The Cage number":"笼子",

  "The Side":"内外侧",

  "The Slot Number":"格子",

  "Barcodid":"玻璃id",

  "Order Number":"订单",

  "delete":"删除",

  "out":"出片",



  "Operation successful":"操作成功",

  "Operation canceled":"操作取消",

  "There is no such order":"没有此订单的玻璃",

  "There are currently tasks":"当前有任务",

  "There is no such glass":"没有此玻璃",

  "There is no such grid":"没有空闲格子",

  "No delete allowed":"不能删除",

  "No out allowed":"不能出片",

  "Are you sure to perform this operation ?":"确定执行此操作?",

  "prompt":"提示",

  "Yes":"是",

  "No":"否",

  "invalid": "无效",

  "addSuccessMessage": "添加成功",

  "deleteConfirmMessage": "确定要删除该权限吗？",

  "confirmButtonText": "确定",

  "cancelButtonText": "取消",

  "deleteSuccessMessage": "删除成功",

  "deleteCancelledMessage": "已取消删除操作",

  "Enter the glass lD": "输入玻璃id",

  "Infeed barcodid": "手动上片",

  "Enter the order number": "输入订单号",

  "Exit the glass by order number": "按订单出片",

  "Please confirm the glass information": "请确认玻璃信息",

  "Please confirm the Ordering Information": "请确认订单信息",

  "Alarm Information": "报警信息",

  "Cage Details": "理片笼详情",

  "order": "订单",

  "length": "长",

  "width": "宽",

  "Operate": "操作",

  "end task": "完成任务",

  "cancel": "取消",

  "confirm": "确认",

  "number": "数量",

  "Outfeed Barcodid": "出片玻璃id",

  "Infeed Barcodid": "进片玻璃id",

  "The Cage number being used": "笼子",

  "The Slot number being used": "格子",

  "Order Nmuber": "订单编号",

  "List Number": "列表编号",

  "Box Number": "箱子编号",

  "Length and Width": "尺寸",

  "id": "id",

  "content": "内容",

  "timeon": "报警时间",

  "endTime": "结束时间",

  "The Cage number": "笼子",

  "The Side": "内外侧",

  "The Slot Number": "格子",

  "Barcodid": "玻璃id",

  "Order Number": "订单",

  "delete": "删除",

  "out": "出片",

  "Operation successful": "操作成功",

  "Operation canceled": "操作取消",

  "There is no such order": "没有此订单的玻璃",

  "There are currently tasks": "当前有任务",

  "There is no such glass": "没有此玻璃",

  "There is no such grid": "没有空闲格子",

  "No delete allowed": "不能删除",

  "No out allowed": "不能出片",

  "Are you sure to perform this operation ?": "确定执行此操作?",

  "prompt": "提示",

  "Yes": "是",

  "No": "否",

  "today": "今天",

  "yesterday": "昨天",

  "week": "一周前",

@@ -280,31 +271,142 @@
  "alacontent": "报警内容",

  "time-on": "开始时间",

  "End-Time": "结束时间",



  "Please enter the password":"请输入密码",

  "Password error":"密码错误",

  "DataBase Connection failed":"数据库连接失败",

  "Distribute parameters":"下发参数",

  "The glass size is not within the range":"玻璃尺寸不在范围内",

  "increase":"添加",

  "Enable":"启用",

  "Disable":"禁用",

  "Usage":"使用率",

  "Space (Pieces)":"空间(片数)",

  "This glass is already in the cage":"笼子里已有此玻璃",

  "Enter the Order lD":"请输入订单id",

  "OrderInfo":"订单信息",

  "Query":"查询",

  "permission update":"权限编辑",

  "query was successful":"查询成功",

  "Scan Code Point":"扫码位",

  "Upper film position":"上片位",

  "Glass Information":"玻璃信息",

  "current Information":"当前信息",

  "Modify Information":"修改信息",

  "Clear Current":"清除当前",

  "Confirm Modification":"确认修改",

  "The glass ID already exists in the loading queue":"上片队列已存在此玻璃id",

  "This glass ID already exists in the sorting cage":"理片笼内已存在此玻璃id"



  "Please enter the password": "请输入密码",

  "Password error": "密码错误",

  "DataBase Connection failed": "数据库连接失败",

  "Distribute parameters": "下发参数",

  "The glass size is not within the range": "玻璃尺寸不在范围内",

  "increase": "添加",

  "Enable": "启用",

  "Disable": "禁用",

  "Usage": "使用率",

  "Space (Pieces)": "空间(片数)",

  "This glass is already in the cage": "笼子里已有此玻璃",

  "Enter the Order lD": "请输入订单id",

  "OrderInfo": "订单信息",

  "Query": "查询",

  "permission update": "权限编辑",

  "query was successful": "查询成功",

  "Scan Code Point": "扫码位",

  "Upper film position": "上片位",

  "Glass Information": "玻璃信息",

  "current Information": "当前信息",

  "Modify Information": "修改信息",

  "Clear Current": "清除当前",

  "Confirm Modification": "确认修改",

  "The glass ID already exists in the loading queue": "上片队列已存在此玻璃id",

  "This glass ID already exists in the sorting cage": "理片笼内已存在此玻璃id",

  "langparameter": {

    "conveyor Velocity(Auto FAST)": "皮带输送自动快速",

    "conveyor Velocity(Auto SLOW)": "皮带输送自动慢速",

    "conveyor Velocity(Manual)": "皮带输送手动速度",

    "A01 A02 TURN JOG Velocity": "A01 A02 翻转点动速度",

    "A01 A02 TRAVEL JOG Velocity": "A01 A02 行走点动速度",

    "B01 B02 TRAVEL JOG Velocity": "B01 B02 行走点动速度",

    "A01 A02 TURN POS Velocity AUTO": "A01 A02 翻转自动定位速度",

    "A01 A02 TURN POS Velocity manual": "A01 A02 翻转手动定位速度",

    "A01 A02 TRAVEL POS Velocity AUTO": "A01 A02 行走自动定位速度",

    "A01 A02 TRAVEL POS Velocity manual": "A01 A02 行走手动定位速度",

    "B01 B02 TRAVEL POS Velocity AUTO": "B01 B02 行走自动定位速度",

    "B01 B02 TRAVEL POS Velocity manual": "B01 B02 行走手动定位速度"

  },

  "langActions": {

    "D01 VFD conveyor": "D01 输送变频",

    "D02 VFD conveyor": "D02 输送变频",

    "D03 VFD conveyor": "D03 输送变频",

    "D04 VFD conveyor": "D04 输送变频",

    "D05 VFD conveyor": "D05 输送变频",

    "D06 VFD conveyor": "D06 输送变频",

    "A01 VFD conveyor": "A01 输送变频",

    "A02 VFD conveyor": "A02 输送变频",

    "B01 VFD conveyor": "B01 输送变频",

    "B02 VFD conveyor": "B02 输送变频",

    "A01 SERVE TURN JOG+": "A01 翻转伺服点动",

    "A02 SERVE TURN JOG-": "A02 翻转伺服点动",

    "A01 SERVE TRAVEL JOG+": "A01 行走伺服点动",

    "A02 SERVE TRAVEL JOG-": "A02 行走伺服点动",

    "B01 SERVE TRAVEL JOG+": "B01 行走伺服点动",

    "B02 SERVE TRAVEL JOG-": "B02 行走伺服点动",

    "A01 SERVE TURN POS": "A01 翻转伺服定位",

    "A02 SERVE TURN POS": "A02 翻转伺服定位",

    "A01 SERVE TRAVEL POS": "A01 行走伺服定位",

    "A02 SERVE TRAVEL POS": "A02 行走伺服定位",

    "B01 SERVE TRAVEL POS": "B01 行走伺服定位",

    "B02 SERVE TRAVEL POS": "B02 行走伺服定位",

    "B01 YV TURN": "B01 抬起电磁阀",

    "B01 YV UP DOWN": "B01 上升下降电磁阀",

    "B02 YV TURN": "B02 抬起电磁阀",

    "B02 YV UP DOWN": "B02 上升下降电磁阀"

  },

  "Signlang": {

    "D01.SR dec": "D01.减速传感器",

    "D01.SR in pos": "D01.到位传感器",

    "D02.SR dec": "D02.减速传感器",

    "D02.SR in pos": "D02.到位传感器",

    "D03.SR into": "D03.进片传感器",

    "D03.SR dec": "D03.减速传感器",

    "D03.SR in pos": "D03.到位传感器",

    "D04.SR dec": "D04.减速传感器",

    "D04.SR in pos": "D04.到位传感器",

    "D05.SR dec": "D05.减速传感器",

    "D05.SR in pos": "D05.到位传感器",

    "D06.SR dec": "D06.减速传感器",

    "D06.SR in pos": "D06.到位传感器",

    "B01.SR out dec": "B01.出片减速传感器",

    "B01.SR out in pos": "B01.出片到位传感器",

    "B01.SR in dec": "B01.进片减速传感器",

    "B01.SR in in pos": "B01.进片到位传感器",

    "B01.SR turn on": "B01.翻转上到位传感器",

    "B01.SR turn off": "B01.翻转下到位传感器",

    "B01.SR up": "B01.上升到位传感器",

    "B01.SR down": "B01.下降到位传感器",

    "B02.SR out dec": "B02.出片减速传感器",

    "B02.SR out in pos": "B02.出片到位传感器",

    "B02.SR in dec": "B02.进片减速传感器",

    "B02.SR in in pos": "B02.进片到位传感器",

    "B02.SR turn on": "B02.翻转上到位传感器",

    "B02.SR turn off": "B02.翻转下到位传感器",

    "B02.SR up": "B02.上升到位传感器",

    "B02.SR down": "B02.下降到位传感器",

    "B01.SR out safety": "B01.出片安全传感器",

    "B01.SR in safety": "B01.进片安全传感器",

    "B02.SR out safety": "B02.出片安全传感器",

    "SB.start(+)": "SB.启动（+）按钮",

    "SB.stop(1)": "SB.停止（-）按钮",

    "SB.reset": "SB.复位按钮",

    "SB.auto/manul": "SB.手/自切换按钮",

    "SB.pause": "SB.暂停按钮",

    "SB.emg": "SB.急停按钮",

    "D01.SB.start": "D01.启动",

    "D06.SB.start": "D06.启动",

    "B02.SR in safety": "B02.进片安全传感器",

    "SAFETYDOOR.requset": "安全门请求进入",

    "SAFETYDOOR.confirm": "安全门确认",

    "SAFETYDOOR.reset": "安全门复位",

    "LED.red": "三色灯红",

    "LED.green": "三色灯绿",

    "LED.yellow": "三色灯黄",

    "D01.LED.green": "D01.绿灯",

    "D06.LED.green": "D06.绿灯",

    "B01.YV.turn": "B01.电磁阀翻转",

    "B01.YV.up down": "B01.电磁阀上升下降",

    "B01.YV.gassing": "B01.电磁阀吹气",

    "B02.YV.turn": "B02.电磁阀翻转",

    "B02.YV.up down": "B02.电磁阀上升下降",

    "B02.YV.gassing": "B02.电磁阀吹气",

    "SAFETYDOOR.led": "安全门状态灯",

    "SAFETYDOOR.open": "安全门打开"

  },

  "Statelang": {

    "D01.State": "D01.状态",

    "D02.State": "D02.状态",

    "B01.State": "B01.状态",

    "B02.State": "B02.状态",

    "A01.State": "A01.状态",

    "A02.State": "A02.状态",

    "D03.State": "D03.状态",

    "D04.State": "D04.状态",

    "D05.State": "D05.状态",

    "D06.State": "D06.状态"

  }

}

 springboot-vue3/src/main/java/com/example/springboot/controller/HomeController.java

@@ -22,232 +22,245 @@
@RestController
@RequestMapping("/home")
public class HomeController {
    @Autowired
    HomeMapper homeMapper;
  @Autowired
  HomeMapper homeMapper;

    @Autowired
    HomeService storageRackService;
  @Autowired
  HomeService storageRackService;

    @Autowired
    SpianService spianService;
  @Autowired
  SpianService spianService;

    @Autowired
    SpianMapper spianMapper;
    
    //查询理片笼使用情况
    @GetMapping("/load")
    public Result selectAll() {
        List<StorageCage> storageCagelist = homeMapper.selectAll();
        Map<String, Object> map = new HashMap<>();
        map.put("list", storageCagelist);
        return Result.success(map);
    }
    //查询理片笼玻璃情况
    @GetMapping("/loads")
    public Result selectRack() {
        List<StorageCage> storageCagelist1 = homeMapper.selectRack1();
        List<StorageCage> storageCagelist2 = homeMapper.selectRack2();
        List<StorageCage> storageCagelist3 = homeMapper.selectRack3();
        List<StorageCage> storageCagelist4 = homeMapper.selectRack4();
        Map<String, Object> map = new HashMap<>();
        map.put("list1", storageCagelist1);
        map.put("list2", storageCagelist2);
        map.put("list3", storageCagelist3);
        map.put("list4", storageCagelist4);
        return Result.success(map);
    }
    //查询进/出片任务
    @GetMapping("/loadinout")
    public Result selectinout(Integer types) {
        List<StorageCage> storageCageinout = homeMapper.selectinout(types);
        Map<String, Object> map = new HashMap<>();
        map.put("list", storageCageinout);
        return Result.success(map);
    }
    //按订单出片
    @GetMapping("/InsertOrder")
    public Result InsertOrder(String orderid) {
        short result = homeMapper.SelectOrder(orderid);
        Map<String, Object> map = new HashMap<>();
        if (result > 0) {
            homeMapper.updateOrder();
            homeMapper.InsertOrder(orderid);
            map.put("message", "200");
        } else {
            map.put("message", "500");
        }
        return Result.success(map);
    }
    //根据玻璃id手动上片
    @GetMapping("/Addglassid")
    public Result Addglassid(String glassid) {
        Map<String, Object> map = new HashMap<>();
        short taskno = homeMapper.SelectInTask();
        if (taskno > 0) {
            map.put("message2", "500");
        } else {
            // 调用伍上片函数
            short results = spianService.selectAll(glassid);
            if (results == 200) {
                map.put("message2", "200");
            } else if (results == 300) {
                map.put("message2", "300");
            } else if (results == 400) {
                map.put("message2", "400");
            }
        }
        return Result.success(map);
    }
    //手动完成进/出片任务
    @GetMapping("/UpdateTask")
    public Result UpdateTask(Integer types, Integer shelfrack, String glassid) {
        Map<String, Object> map = new HashMap<>();
        homeMapper.UpdateTask(types);
        StorageCage glass = homeMapper.SelectGlassInfo(glassid);
        if (types == 0) {
            // spianMapper.UpdataAddCage1(glass.getGlassWidth(),glass.getCage(),glass.getCell());
            homeMapper.UpdateCageTask1(glassid);
            S7control.getinstance().WriteWord("DB105.14", (short) 0);
        } else {
  @Autowired
  SpianMapper spianMapper;

            spianMapper.UpdataOutCage1(glass.getGlassWidth(), glass.getCage(), glass.getCell());
            homeMapper.UpdateCageTask2(glassid);
            S7control.getinstance().WriteWord("DB105.12", (short) 0);
        }
        map.put("message3", "200");
        return Result.success(map);
    }
    //查询报警信息
    @GetMapping("/SelectAlarmmgInfo")
    public Result SelectAlarmmgInfo() {
        List<alarmmg> alarmmg = homeMapper.SelectAlarmmgInfo();
        Map<String, Object> map = new HashMap<>();
        map.put("alarmmg", alarmmg);
        return Result.success(map);
    }
    //查询理片笼详情
    @GetMapping("/SelectCageInfo")
    public Result SelectCageInfo(short cage) {
        List<StorageCage> cageinfo = homeMapper.SelectCageInfo(cage);
        Map<String, Object> map = new HashMap<>();
        map.put("cageinfo", cageinfo);
        return Result.success(map);
    }
    //手动删除理片笼玻璃
    @GetMapping("/DeleteByGlassID")
    public Result DeleteByGlassID(String glassid) {
        StorageCage glassinfor = homeMapper.SelectGlassInfo(glassid);
        spianMapper.UpdataOutCage1(glassinfor.getGlassWidth(), glassinfor.getCage(), glassinfor.getCell());
        homeMapper.DeleteByGlassID(glassid);
        Map<String, Object> map = new HashMap<>();
        map.put("message3", "200");
        return Result.success(map);
    }
    //根据玻璃id手动出片
    @GetMapping("/OutByGlassID")
    public Result OutByGlassID(String glassid) {
        Map<String, Object> map = new HashMap<>();
        // 调用伍上片函数
        short result = homeMapper.SelectStorageByGlassId(glassid);
        if (result > 0) {
            Short results = spianService.selectout2(glassid);
            if (results == 200) {
                map.put("message2", "200");
            } else if (results == 300) {
                map.put("message2", "300");
            } 
        }else{
            map.put("message2", "500");
        }
  // 查询理片笼使用情况
  @GetMapping("/load")
  public Result selectAll() {
    List<StorageCage> storageCagelist = homeMapper.selectAll();
    Map<String, Object> map = new HashMap<>();
    map.put("list", storageCagelist);
    return Result.success(map);
  }

        return Result.success(map);
  // 查询理片笼玻璃情况
  @GetMapping("/loads")
  public Result selectRack() {
    List<StorageCage> storageCagelist1 = homeMapper.selectRack1();
    List<StorageCage> storageCagelist2 = homeMapper.selectRack2();
    List<StorageCage> storageCagelist3 = homeMapper.selectRack3();
    List<StorageCage> storageCagelist4 = homeMapper.selectRack4();
    Map<String, Object> map = new HashMap<>();
    map.put("list1", storageCagelist1);
    map.put("list2", storageCagelist2);
    map.put("list3", storageCagelist3);
    map.put("list4", storageCagelist4);
    return Result.success(map);
  }

  // 查询进/出片任务
  @GetMapping("/loadinout")
  public Result selectinout(Integer types) {
    List<StorageCage> storageCageinout = homeMapper.selectinout(types);
    Map<String, Object> map = new HashMap<>();
    map.put("list", storageCageinout);
    return Result.success(map);
  }

  // 按订单出片
  @GetMapping("/InsertOrder")
  public Result InsertOrder(String orderid) {
    short result = homeMapper.SelectOrder(orderid);
    Map<String, Object> map = new HashMap<>();
    if (result > 0) {
      homeMapper.updateOrder();
      homeMapper.InsertOrder(orderid);
      map.put("message", "200");
    } else {
      map.put("message", "500");
    }
    //加载小车位置
    @GetMapping("/Loadcarlist")
    public Result Loadcarlist() {
        List<CarPosition> carlist = homeMapper.Loadcarlist();
        Map<String, Object> map = new HashMap<>();
        map.put("carlist", carlist);
        return Result.success(map);
    return Result.success(map);
  }

  // 根据玻璃id手动上片
  @GetMapping("/Addglassid")
  public Result Addglassid(String glassid) {
    Map<String, Object> map = new HashMap<>();
    short taskno = homeMapper.SelectInTask();
    if (taskno > 0) {
      map.put("message2", "500");
    } else {
      // 调用伍上片函数
      short results = spianService.selectAll(glassid);
      if (results == 200) {
        map.put("message2", "200");
      } else if (results == 300) {
        map.put("message2", "300");
      } else if (results == 400) {
        map.put("message2", "400");
      }
    }
    //查询确认密码
    @GetMapping("/SelectPassword")
    public Result SelectPassword() {
        String pwdct = homeMapper.SelectPassword();
        Map<String, Object> map = new HashMap<>();
        map.put("password", pwdct);
        return Result.success(map);
    return Result.success(map);
  }

  // 手动完成进/出片任务
  @GetMapping("/UpdateTask")
  public Result UpdateTask(Integer types, Integer shelfrack, String glassid) {
    Map<String, Object> map = new HashMap<>();
    homeMapper.UpdateTask(types);
    StorageCage glass = homeMapper.SelectGlassInfo(glassid);
    if (types == 0) {
      // spianMapper.UpdataAddCage1(glass.getGlassWidth(),glass.getCage(),glass.getCell());
      homeMapper.UpdateCageTask1(glassid);
      S7control.getinstance().WriteWord("DB105.14", (short) 0);
    } else {

      spianMapper.UpdataOutCage1(glass.getGlassWidth(), glass.getCage(), glass.getCell());
      homeMapper.UpdateCageTask2(glassid);
      S7control.getinstance().WriteWord("DB105.12", (short) 0);
    }
    //根据玻璃id查询玻璃信息
    @GetMapping("/SelectGlassByGlassID")
    public Result SelectGlassByGlassID(String glassid) {
        Glass Glass = homeMapper.SelectGlassByGlassID(glassid);
        Map<String, Object> map = new HashMap<>();
        map.put("form", Glass);
        return Result.success(map);
    }
    //启用/禁用理片笼格子
    @GetMapping("/Disabled")
    public Result Disabled(short cage, short cell, short disabled) {
        homeMapper.Disabled(cage, cell, disabled);
        Map<String, Object> map = new HashMap<>();
        map.put("message", "200");
        return Result.success(map);
    }
    //手动往理片笼添加玻璃
    @PostMapping("/Inglassid")
    public Result Inglassid(short cage, short cell, short tier, @RequestBody Glass glass) {
        Map<String, Object> map = new HashMap<>();
        short result = homeMapper.SelectStorageByGlassId(glass.getGlassId());
        if (result > 0) {
            map.put("message", "300");
        } else {
            homeMapper.Inglassid(glass, cage, cell, tier);
            spianMapper.UpdataAddCage1(glass.getGlassWidth(), cage, cell);
        }
        return Result.success(map);
    map.put("message3", "200");
    return Result.success(map);
  }

  // 查询报警信息
  @GetMapping("/SelectAlarmmgInfo")
  public Result SelectAlarmmgInfo() {
    List<alarmmg> alarmmg = homeMapper.SelectAlarmmgInfo();
    Map<String, Object> map = new HashMap<>();
    map.put("alarmmg", alarmmg);
    return Result.success(map);
  }

  // 查询理片笼详情
  @GetMapping("/SelectCageInfo")
  public Result SelectCageInfo(short cage) {
    List<StorageCage> cageinfo = homeMapper.SelectCageInfo(cage);
    Map<String, Object> map = new HashMap<>();
    map.put("cageinfo", cageinfo);
    return Result.success(map);
  }

  // 手动删除理片笼玻璃
  @GetMapping("/DeleteByGlassID")
  public Result DeleteByGlassID(String glassid) {
    StorageCage glassinfor = homeMapper.SelectGlassInfo(glassid);
    spianMapper.UpdataOutCage1(glassinfor.getGlassWidth(), glassinfor.getCage(), glassinfor.getCell());
    homeMapper.DeleteByGlassID(glassid);
    Map<String, Object> map = new HashMap<>();
    map.put("message3", "200");
    return Result.success(map);
  }

  // 根据玻璃id手动出片
  @GetMapping("/OutByGlassID")
  public Result OutByGlassID(String glassid) {
    Map<String, Object> map = new HashMap<>();
    // 调用伍上片函数
    short result = homeMapper.SelectStorageByGlassId(glassid);
    if (result > 0) {
      Short results = spianService.selectout2(glassid);
      if (results == 200) {
        map.put("message2", "200");
      } else if (results == 300) {
        map.put("message2", "300");
      }
    } else {
      map.put("message2", "500");
    }

    //查询玻璃信息
    @PostMapping("/SelectGlass")
    public Result SelectGlass(String orderid) {
        Map<String, Object> map = new HashMap<>();
        List<Glass> glass=homeMapper.SelectGlass(orderid);
        map.put("glass", glass);
        return Result.success(map);
    }
    return Result.success(map);
  }

    //手动添加扫码位玻璃
    @PostMapping("/InsertQueueGlassId")
    public Result InsertQueueGlassId(String glassid,Short id) {
        Map<String, Object> map = new HashMap<>();
        short result = homeMapper.SelectStorageByGlassId(glassid);
        if (result > 0) {
            map.put("message", "300");
        }else{
            homeMapper.InsertQueueGlassId(glassid,id);
            map.put("message", "200");
        }
        return Result.success(map);
    }
    
    //确认扫码位玻璃信息
    @PostMapping("/UpdateQueueState")
    public Result UpdateQueueState() {
        homeMapper.UpdateQueueState();
        Map<String, Object> map = new HashMap<>();
        map.put("message", "200");
        return Result.success(map);
    }
  // 加载小车位置
  @GetMapping("/Loadcarlist")
  public Result Loadcarlist() {
    List<CarPosition> carlist = homeMapper.Loadcarlist();
    Map<String, Object> map = new HashMap<>();
    map.put("carlist", carlist);
    return Result.success(map);
  }

    //清除上片队列玻璃
    @PostMapping("/DeleteQueueGlass")
    public Result DeleteQueueGlass(String id) {
        homeMapper.DeleteQueueGlass(id);
        Map<String, Object> map = new HashMap<>();
        map.put("message", "200");
        return Result.success(map);
  // 查询确认密码
  @GetMapping("/SelectPassword")
  public Result SelectPassword() {
    String pwdct = homeMapper.SelectPassword();
    Map<String, Object> map = new HashMap<>();
    map.put("password", pwdct);
    return Result.success(map);
  }

  // 根据玻璃id查询玻璃信息
  @GetMapping("/SelectGlassByGlassID")
  public Result SelectGlassByGlassID(String glassid) {
    Glass Glass = homeMapper.SelectGlassByGlassID(glassid);
    Map<String, Object> map = new HashMap<>();
    map.put("form", Glass);
    return Result.success(map);
  }

  // 启用/禁用理片笼格子
  @GetMapping("/Disabled")
  public Result Disabled(short cage, short cell, short disabled) {
    homeMapper.Disabled(cage, cell, disabled);
    Map<String, Object> map = new HashMap<>();
    map.put("message", "200");
    return Result.success(map);
  }

  // 手动往理片笼添加玻璃
  @PostMapping("/Inglassid")
  public Result Inglassid(short cage, short cell, short tier, @RequestBody Glass glass) {
    Map<String, Object> map = new HashMap<>();
    short result = homeMapper.SelectStorageByGlassId(glass.getGlassId());
    if (result > 0) {
      map.put("message", "300");
    } else {
      homeMapper.Inglassid(glass, cage, cell, tier);
      spianMapper.UpdataAddCage1(glass.getwidth(), cage, cell);
    }
    
    
    return Result.success(map);
  }

  // 查询玻璃信息
  @PostMapping("/SelectGlass")
  public Result SelectGlass(String orderid) {
    Map<String, Object> map = new HashMap<>();
    List<Glass> glass = homeMapper.SelectGlass(orderid);
    map.put("glass", glass);
    return Result.success(map);
  }

  // 手动添加扫码位玻璃
  @PostMapping("/InsertQueueGlassId")
  public Result InsertQueueGlassId(String glassid, Short id) {
    Map<String, Object> map = new HashMap<>();
    short result = homeMapper.SelectStorageByGlassId(glassid);
    if (result > 0) {
      map.put("message", "300");
    } else {
      homeMapper.InsertQueueGlassId(glassid, id);
      map.put("message", "200");
    }
    return Result.success(map);
  }

  // 确认扫码位玻璃信息
  @PostMapping("/UpdateQueueState")
  public Result UpdateQueueState() {
    homeMapper.UpdateQueueState();
    Map<String, Object> map = new HashMap<>();
    map.put("message", "200");
    return Result.success(map);
  }

  // 清除上片队列玻璃
  @PostMapping("/DeleteQueueGlass")
  public Result DeleteQueueGlass(String id) {
    homeMapper.DeleteQueueGlass(id);
    Map<String, Object> map = new HashMap<>();
    map.put("message", "200");
    return Result.success(map);
  }

}

 springboot-vue3/src/main/java/com/example/springboot/entity/Glass.java

@@ -1,57 +1,58 @@
package com.example.springboot.entity;

public class Glass{
    private Integer id;
    private String orderId;
    private double width;
    private double height;
    private String glassId;
    
    
public class Glass {
  private Integer id;
  private String orderId;
  private double width;
  private double height;
  private String glassId;

    public Integer id() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getId() {
        return id;
    }
  public Integer id() {
    return id;
  }

    public String getOrderId() {
        return orderId;
    }
  public void setId(Integer id) {
    this.id = id;
  }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }
    
    public double getwidth() {
        return width;
    }
  public Integer getId() {
    return id;
  }

    public void setHeight(double height) {
        this.height = height;
    }
  public String getOrderId() {
    return orderId;
  }

    public double getHeight() {
        return height;
    }
  public void setOrderId(String orderId) {
    this.orderId = orderId;
  }

    public void setWidth(double width) {
        this.width = width;
    }
  public double getwidth() {
    return width;
  }

     public String getGlassId() {
        return glassId;
    }
  public void setHeight(double height) {
    this.height = height;
  }

    public void setGlassId(String glassId) {
        this.glassId = glassId;
    }
  public double getHeight() {
    return height;
  }

  
    
  public void setWidth(double width) {
    this.width = width;
  }

  public void getWidth(double width) {
    this.width = width;
  }

  public String getGlassId() {
    return glassId;
  }

  public void setGlassId(String glassId) {
    this.glassId = glassId;
  }

}

 springboot-vue3/src/main/java/com/example/springboot/mapper/SpianMapper.java

@@ -1,11 +1,10 @@
package com.example.springboot.mapper;
import org.apache.ibatis.annotations.*;

import org.apache.ibatis.annotations.*;

import com.example.springboot.entity.Glass;
import com.example.springboot.entity.StorageCage;
import com.example.springboot.entity.StorageTask;


import java.util.List;

@@ -14,131 +13,170 @@
@Mapper

public interface SpianMapper {
    //判断相邻笼子是否有空格  
    @Select("select COUNT(if(a.state1=0,cell,null))as cell,ROUND(id/2)as id from (select *,max(state)as state1 from storage_cage a  GROUP BY cage,cell)as a where (a.cage=#{cage1}-1 or a.cage=#{cage1}+1)and if(a.cage<6,a.cage>0 and a.cage<6,a.cage>5) GROUP BY cage ORDER BY cell desc LIMIT 1")
     int selectCage(int  cage1);
     
     //@Select("(select*from storage_cage as a  where a.state=0 and cage%2=0 ORDER BY id LIMIT 1)union (select a.* from storage_cage a inner join  (select cage,if(shu2=1,shu3,shu5) as gezi from ( select  cage, count(case when state1=1 and state2=0 then cell else null end)as shu1,  count(case when state1=0 then cell else null end) as shu2, min(case when state1=1 and state2=0 then cell else null end) as shu3, min(case when state1=0 then cell else null end) as shu4, min(case when state1=0 or state2=0 then cell else null end) as shu5 from  (select *,max(state) as state1,min(state) as state2 from storage_cage group by cage,cell) as a where  cage%2!=0  GROUP BY cage HAVING shu2>1 or (shu2=1 and shu1>0)  ) as sss limit 1)as b on a.cage=b.cage and a.cell=b.gezi and a.state=0 order by tier limit 1) ORDER BY id LIMIT 1;")
    //获取订单号排序的空订单笼子
     @Select("select a.cage,COUNT(if(a.order_id=#{orderids},a.order_id,null))as orderid,b.shu,c.shu2,a.cell,min(a.state)as state1 from storage_cage a left join (select COUNT(*)shu,cage from storage_cage  where order_id=#{orderids} GROUP BY cage)as b on a.cage=b.cage left join(select cage ,COUNT(glass_id)as shu2 from storage_cage GROUP BY cage)c  on a.cage=c.cage where (order_id=#{orderids} or ''='') GROUP BY cage,cell HAVING state1=0 ORDER BY shu desc,shu2,cage asc; ")
     List<StorageCage> selectAll(String orderids);
  // 判断相邻笼子是否有空格
  @Select("select COUNT(if(a.state1=0,cell,null))as cell,ROUND(id/2)as id from (select *,max(state)as state1 from storage_cage a  GROUP BY cage,cell)as a where (a.cage=#{cage1}-1 or a.cage=#{cage1}+1)and if(a.cage<6,a.cage>0 and a.cage<6,a.cage>5) GROUP BY cage ORDER BY cell desc LIMIT 1")
  int selectCage(int cage1);

     //判断该笼子是否有合适宽度空格
     @Select("select cage,cell,tier,id,ROUND(id/2)as prcId,width from storage_cage where cage=#{cage1} and cell=#{cell} and state=0 and width>=#{width} ORDER BY cell asc,tier desc LIMIT 1")
     StorageCage selectCage1(int  cage1,int cell,double width);
     //判断笼子内玻璃数
     @Select("select COUNT(tier)as tier from storage_cage where  cage=#{cage} and cell=#{cell} and state=1;")
     int selectsum(int cage,int cell);
  // @Select("(select*from storage_cage as a where a.state=0 and cage%2=0 ORDER BY
  // id LIMIT 1)union (select a.* from storage_cage a inner join (select
  // cage,if(shu2=1,shu3,shu5) as gezi from ( select cage, count(case when
  // state1=1 and state2=0 then cell else null end)as shu1, count(case when
  // state1=0 then cell else null end) as shu2, min(case when state1=1 and
  // state2=0 then cell else null end) as shu3, min(case when state1=0 then cell
  // else null end) as shu4, min(case when state1=0 or state2=0 then cell else
  // null end) as shu5 from (select *,max(state) as state1,min(state) as state2
  // from storage_cage group by cage,cell) as a where cage%2!=0 GROUP BY cage
  // HAVING shu2>1 or (shu2=1 and shu1>0) ) as sss limit 1)as b on a.cage=b.cage
  // and a.cell=b.gezi and a.state=0 order by tier limit 1) ORDER BY id LIMIT 1;")
  // 获取订单号排序的空订单笼子
  @Select("select a.cage,COUNT(if(a.order_id=#{orderids},a.order_id,null))as orderid,b.shu,c.shu2,a.cell,min(a.state)as state1 from storage_cage a left join (select COUNT(*)shu,cage from storage_cage  where order_id=#{orderids} GROUP BY cage)as b on a.cage=b.cage left join(select cage ,COUNT(glass_id)as shu2 from storage_cage GROUP BY cage)c  on a.cage=c.cage where (order_id=#{orderids} or ''='') GROUP BY cage,cell HAVING state1=0 ORDER BY shu desc,shu2,cage asc; ")
  List<StorageCage> selectAll(String orderids);

    //@Update("update longzi set glass_id = #{glass_id}, width = #{width}, state = #{state} where cell = #{cell}")
    @Update("update longzi set glass_id =123, width =1600, state =1 where cell =24")
     void  update();
     //获取玻璃信息
     @Select("select orderid,width from glass where glassid=#{glassid}")
     Glass selectGlass(String glassid);
    
    @Insert("insert into storage_task(task_type,task_state,shelf_rack,load_rack)values(#{storage_task},#{task_state},#{shelf_rack},#{load_rack})")
     void insert(StorageTask storageTask);
    
    //出片任务查询
    @Select("select COUNT(order_id)order_id,cage,cell,glasswidth,tier,ROUND(id/2)as prcId,glass_id from storage_cage a where a.order_id=#{orderId} GROUP BY cage,cell ORDER BY cage desc,order_id desc,cell desc,glasswidth desc limit 1")
     StorageCage selectOut(String  orderId);
    // @Select("select cage,cell,tier,glasswidth,ROUND(id/2)as prcId,id,glass_id from storage_cage as a where a.order_id=#{orderId} and state=1 order by cage desc,tier desc,cell desc LIMIT 1")
    //  StorageCage selectOut(String  orderId);
    //按玻璃ID出片任务查询
    @Select("select cage,cell,tier,glasswidth,ROUND(id/2)as prcId,id from storage_cage as a where a.glass_id=#{glassid} and state=1 order by cage desc,tier desc,cell desc LIMIT 1")
     StorageCage selectOut2(String  glassid);
  // 判断该笼子是否有合适宽度空格
  @Select("select cage,cell,tier,id,ROUND(id/2)as prcId,width from storage_cage where cage=#{cage1} and cell=#{cell} and state=0 and width>=#{width} ORDER BY cell asc,tier desc LIMIT 1")
  StorageCage selectCage1(int cage1, int cell, double width);

    //判断出片为1时，是否可直接出片
    @Select("select COUNT(state) from storage_cage where cage=#{cage} and cell=#{cell}")
     int selectGlassState(int  cage,int cell);
  // 判断笼子内玻璃数
  @Select("select COUNT(tier)as tier from storage_cage where  cage=#{cage} and cell=#{cell} and state=1;")
  int selectsum(int cage, int cell);

     //判断该调拨的笼子
     @Select("select glass_id,cage,cell,max(state)as shu,ROUND(id/2)as prcid,id from storage_cage where width>=#{width} and cage>#{cage1} and cage<#{cage2} GROUP BY cage,cell HAVING shu=0 order by abs(#{cage} - cage) limit 1;")
     StorageCage selectGlassCage(int cage,double width,int cage1,int cage2);
  // @Update("update longzi set glass_id = #{glass_id}, width = #{width}, state =
  // #{state} where cell = #{cell}")
  @Update("update longzi set glass_id =123, width =1600, state =1 where cell =24")
  void update();

    //删除笼子信息(出片)
    @Update("update storage_cage as a set state=#{state},glass_id=#{glassid},order_id=#{orderid},glasswidth=0 where cage=#{cage} and cell=#{cell} and tier=#{tier};")
    void UpdataGlassCage(String orderid,String glassid,double width,int cage,int cell,int tier,int state);
  // 获取玻璃信息
  @Select("select orderid,width from glass where glassid=#{glassid}")
  Glass selectGlass(String glassid);

    //修改笼子信息(进片)
    @Update("update storage_cage set state=#{state},glass_id=#{glassid},order_id=#{orderid},glasswidth=#{width} where id=#{id};")
    void UpdataAddCage(String orderid,String glassid,double width,int cage,int cell,int id,int state);
     //修改笼子信息(多片进片)
    @Update("update storage_cage set state=#{state},glass_id=#{glassid},order_id=#{orderid},glasswidth=#{width} where cage=#{cage} and cell=#{cell} and tier=#{tier};")
    void UpdataAddqueCage(String orderid,String glassid,double width,int cage,int cell,int tier,int state);
    //修改同笼子格子宽度
     @Update("update storage_cage set width=width-#{width} where   cage=#{cage} and cell=#{cell};")
    void UpdataAddCage1(double width,int cage,int cell);
    //修改同笼子格子宽度
     @Update("update storage_cage set state=#{state} where   state=#{oldstate};")
    void UpdataAddCageState(int state,int oldstate);
    //修改同笼子格子宽度(出片)
     @Update("update storage_cage set width=width+#{width} where   cage=#{cage} and cell=#{cell};")
    void UpdataOutCage1(double width,int cage,int cell);
    //调拨更换笼子信息
    @Update("update storage_cage as a,(select*from storage_cage b where b.cage=#{cage} and b.cell=#{cell} and b.tier=2)as b set a.glass_id=b.glass_id,a.order_id=b.order_id,a.state=1,a.glasswidth=b.glasswidth where a.id=#{id1}")
    void UpdateDBCage(int id1,int cage,int cell);
    // @Insert("insert into user(name, date, address, user_no) values (#{name}, #{date}, #{address}, #{userNo})")
    // void insert (Spian spian);
    //新增任务表
    @Insert("INSERT INTO `canadames`.`storage_task`(`task_type`, `task_state`, `shelf_rack`, `load_rack`,start_time,glass_id) VALUES (#{tasktype},#{taskstate},#{shelfrack},#{loadrack},now(),#{glassid});")
    void Inserttask(int tasktype,int taskstate,int shelfrack,int loadrack,String glassid);
    //修改任务表
    @Update("update storage_task set task_state=#{state} where task_type=#{type} and task_state=0;")
    void Updatetask(int state,int type);
    //修改任务表
    @Update("update storage_task set task_state=1 where (task_type=1 or task_type=2) and task_state=0;")
    void UpdatetaskOut();
    //查询按订单出片
    @Select("select order_id state from order_out where state=0")
    String  SelectOrderout();
    //内外片调换
    @Update("update storage_cage as a,(select*from storage_cage b where b.cage=#{cage} and b.cell=#{cell} and b.tier=2)as b set a.glass_id=b.glass_id,a.order_id=b.order_id,a.state=1,a.glasswidth=b.glasswidth where a.cage=#{cage} and a.cell=#{cell} and a.tier=1")
    void UpdateDBCage1(int cage,int cell);
    //清除内片数据
    @Update("update storage_cage set glass_id='',order_id='',state=0,glasswidth=0 where a.cage=#{cage} and a.cell=#{cell} and a.tier=1;")
    void UpdateDBCage2(int cage,int cell);
    //判断是否有调拨完后出片的任务
    @Select("select COUNT(*)as id,glass_id from storage_task where (task_type=1 or task_type=2) and task_state=0;")
    Glass SelectDBOut();
    //根据笼子格子层数获取玻璃id
     @Select("select glass_id from storage_cage where cage=#{cage} and cell=#{cell} and tier=2;")
     String SelectGlassid(int cage,int cell);
     //根据笼子格子层数获取玻璃id
     @Select("SELECT COUNT(*) FROM `storage_cage` where state=3;")
     Integer Selectoutstate();
     //添加任务序列
     //获取进片队列id
     @Insert("INSERT INTO `canadames`.`queue`(`glassid`, `type`, `state`,width) VALUES (#{glassid},#{type},0,#{width});")
     void insertqueue(String glassid,int type,double width);
     //获取任务序列
     @Select("select glassid,orderid,width,type from queue where state=#{state}")
     StorageCage SelectQueue(int state);
     //获取序列表的玻璃宽
     @Select("select sum(width)+400 as width,orderid from queue where state=0 limit 1")
     StorageCage SelectQueueWidth();
    //判断该笼子是否有合适完整空格
     @Select("select cage,cell,tier,id,ROUND(id/2)as prcId,width,max(state)state1 from storage_cage where cage=#{cage1} and cell=#{cell} and state=0 and width>=#{width} HAVING state1=0 ORDER BY cell asc,tier desc LIMIT 1")
     StorageCage selectqueCage1(int  cage1,int cell,double width);
     //获取序列表的玻璃
     @Select("select glassid,orderid,width from queue where state=0 and type=#{type}")
     Glass SelectQueueGlass(int type);
     //多片出库清除一整个空格
     @Update("update storage_cage set glass_id='',order_id='',glasswidth=0,width=2750,state=0 where cage=#{cage} and cell=#{cell}")
     void UpdatequeOut(int cage,int cell);
     //判断序列表里的玻璃是否是同一订单
     @Select("select  COUNT(distinct orderid) from queue ")
     int SelectQueOrder();
     //寻找可以多片出片的玻璃
     @Select("select cage,cell,ROUND(id/2)as prcId,width,count(glass_id)shu from storage_cage where order_id=#{orderid} and (cage!=#{cage} or cell!=#{cell}) GROUP BY cage,cell HAVING shu=1 ORDER BY cage desc,cell desc limit 1")
     StorageCage SelectQueout(String orderid,int cage,int cell);
     //获取进片队列id
     @Select("select glassid from queue where type=1 and state=0;")
     @Select("select glassid from queue where type=1")
     String Selectqueueid();
     //获取进片队列id
     @Select("select state from queue where type=1")
     String Selectqueuestate();
  @Insert("insert into storage_task(task_type,task_state,shelf_rack,load_rack)values(#{storage_task},#{task_state},#{shelf_rack},#{load_rack})")
  void insert(StorageTask storageTask);

  // 出片任务查询
  @Select("select COUNT(order_id)order_id,cage,cell,glasswidth,tier,ROUND(id/2)as prcId,glass_id from storage_cage a where a.order_id=#{orderId} GROUP BY cage,cell ORDER BY cage desc,order_id desc,cell desc,glasswidth desc limit 1")
  StorageCage selectOut(String orderId);

  // @Select("select cage,cell,tier,glasswidth,ROUND(id/2)as prcId,id,glass_id
  // from storage_cage as a where a.order_id=#{orderId} and state=1 order by cage
  // desc,tier desc,cell desc LIMIT 1")
  // StorageCage selectOut(String orderId);
  // 按玻璃ID出片任务查询
  @Select("select cage,cell,tier,glasswidth,ROUND(id/2)as prcId,id from storage_cage as a where a.glass_id=#{glassid} and state=1 order by cage desc,tier desc,cell desc LIMIT 1")
  StorageCage selectOut2(String glassid);

  // 判断出片为1时，是否可直接出片
  @Select("select COUNT(state) from storage_cage where cage=#{cage} and cell=#{cell}")
  int selectGlassState(int cage, int cell);

  // 判断该调拨的笼子
  @Select("select glass_id,cage,cell,max(state)as shu,ROUND(id/2)as prcid,id from storage_cage where width>=#{width} and cage>#{cage1} and cage<#{cage2} GROUP BY cage,cell HAVING shu=0 order by abs(#{cage} - cage) limit 1;")
  StorageCage selectGlassCage(int cage, double width, int cage1, int cage2);

  // 删除笼子信息(出片)
  @Update("update storage_cage as a set state=#{state},glass_id=#{glassid},order_id=#{orderid},glasswidth=0 where cage=#{cage} and cell=#{cell} and tier=#{tier};")
  void UpdataGlassCage(String orderid, String glassid, double width, int cage, int cell, int tier, int state);

  // 修改笼子信息(进片)
  @Update("update storage_cage set state=#{state},glass_id=#{glassid},order_id=#{orderid},glasswidth=#{width} where id=#{id};")
  void UpdataAddCage(String orderid, String glassid, double width, int cage, int cell, int id, int state);

  // 修改笼子信息(多片进片)
  @Update("update storage_cage set state=#{state},glass_id=#{glassid},order_id=#{orderid},glasswidth=#{width} where cage=#{cage} and cell=#{cell} and tier=#{tier};")
  void UpdataAddqueCage(String orderid, String glassid, double width, int cage, int cell, int tier, int state);

  // 修改同笼子格子宽度
  @Update("update storage_cage set width=width-#{width} where   cage=#{cage} and cell=#{cell};")
  void UpdataAddCage1(double width, int cage, int cell);

  // 修改同笼子格子宽度
  @Update("update storage_cage set state=#{state} where   state=#{oldstate};")
  void UpdataAddCageState(int state, int oldstate);

  // 修改同笼子格子宽度(出片)
  @Update("update storage_cage set width=width+#{width} where   cage=#{cage} and cell=#{cell};")
  void UpdataOutCage1(double width, int cage, int cell);

  // 调拨更换笼子信息
  @Update("update storage_cage as a,(select*from storage_cage b where b.cage=#{cage} and b.cell=#{cell} and b.tier=2)as b set a.glass_id=b.glass_id,a.order_id=b.order_id,a.state=1,a.glasswidth=b.glasswidth where a.id=#{id1}")
  void UpdateDBCage(int id1, int cage, int cell);

  // @Insert("insert into user(name, date, address, user_no) values (#{name},
  // #{date}, #{address}, #{userNo})")
  // void insert (Spian spian);
  // 新增任务表
  @Insert("INSERT INTO `canadames`.`storage_task`(`task_type`, `task_state`, `shelf_rack`, `load_rack`,start_time,glass_id) VALUES (#{tasktype},#{taskstate},#{shelfrack},#{loadrack},now(),#{glassid});")
  void Inserttask(int tasktype, int taskstate, int shelfrack, int loadrack, String glassid);

  // 修改任务表
  @Update("update storage_task set task_state=#{state} where task_type=#{type} and task_state=0;")
  void Updatetask(int state, int type);

  // 修改任务表
  @Update("update storage_task set task_state=1 where (task_type=1 or task_type=2) and task_state=0;")
  void UpdatetaskOut();

  // 查询按订单出片
  @Select("select order_id state from order_out where state=0")
  String SelectOrderout();

  // 内外片调换
  @Update("update storage_cage as a,(select*from storage_cage b where b.cage=#{cage} and b.cell=#{cell} and b.tier=2)as b set a.glass_id=b.glass_id,a.order_id=b.order_id,a.state=1,a.glasswidth=b.glasswidth where a.cage=#{cage} and a.cell=#{cell} and a.tier=1")
  void UpdateDBCage1(int cage, int cell);

  // 清除内片数据
  @Update("update storage_cage set glass_id='',order_id='',state=0,glasswidth=0 where a.cage=#{cage} and a.cell=#{cell} and a.tier=1;")
  void UpdateDBCage2(int cage, int cell);

  // 判断是否有调拨完后出片的任务
  @Select("select COUNT(*)as id,glass_id from storage_task where (task_type=1 or task_type=2) and task_state=0;")
  Glass SelectDBOut();

  // 根据笼子格子层数获取玻璃id
  @Select("select glass_id from storage_cage where cage=#{cage} and cell=#{cell} and tier=2;")
  String SelectGlassid(int cage, int cell);

  // 根据笼子格子层数获取玻璃id
  @Select("SELECT COUNT(*) FROM `storage_cage` where state=3;")
  Integer Selectoutstate();

  // 添加任务序列
  // 获取进片队列id
  @Insert("INSERT INTO `canadames`.`queue`(`glassid`, `type`, `state`,width) VALUES (#{glassid},#{type},0,#{width});")
  void insertqueue(String glassid, int type, double width);

  // 获取任务序列
  @Select("select glassid,orderid,width,type from queue where state=#{state}")
  StorageCage SelectQueue(int state);

  // 获取序列表的玻璃宽
  @Select("select sum(width)+400 as width,orderid from queue where state=0 limit 1")
  StorageCage SelectQueueWidth();

  // 判断该笼子是否有合适完整空格
  @Select("select cage,cell,tier,id,ROUND(id/2)as prcId,width,max(state)state1 from storage_cage where cage=#{cage1} and cell=#{cell} and state=0 and width>=#{width} HAVING state1=0 ORDER BY cell asc,tier desc LIMIT 1")
  StorageCage selectqueCage1(int cage1, int cell, double width);

  // 获取序列表的玻璃
  @Select("select glassid,orderid,width from queue where state=0 and type=#{type}")
  Glass SelectQueueGlass(int type);

  // 多片出库清除一整个空格
  @Update("update storage_cage set glass_id='',order_id='',glasswidth=0,width=2750,state=0 where cage=#{cage} and cell=#{cell}")
  void UpdatequeOut(int cage, int cell);

  // 判断序列表里的玻璃是否是同一订单
  @Select("select  COUNT(distinct orderid) from queue ")
  int SelectQueOrder();

  // 寻找可以多片出片的玻璃
  @Select("select cage,cell,ROUND(id/2)as prcId,width,count(glass_id)shu from storage_cage where order_id=#{orderid} and (cage!=#{cage} or cell!=#{cell}) GROUP BY cage,cell HAVING shu=1 ORDER BY cage desc,cell desc limit 1")
  StorageCage SelectQueout(String orderid, int cage, int cell);
  // 获取进片队列id

  @Select("select glassid from queue where type=1")
  String Selectqueueid();

  // 获取进片队列id
  @Select("select state from queue where type=1")
  String Selectqueuestate();
}