Merge remote-tracking branch 'origin/master'

src/main/java/com/glxp/api/constant/ConstantStatus.java

@@ -207,6 +207,7 @@ public class ConstantStatus {
     public static final int FROM_RECEIVE = 13;          //领用单据转单
     public static final int FROM_THRORDER = 14;         //第三方单据转单
     public static final int FROM_Order = 15;          //采购计划转单
+    public static final int FROM_BACK = 17;           //出库转退货单;
 
 
     //DI类型

src/main/java/com/glxp/api/controller/inout/IoCodeTempController.java

@@ -1,5 +1,6 @@
 package com.glxp.api.controller.inout;
 
+import cn.hutool.Hutool;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.StrUtil;
 import com.github.pagehelper.PageInfo;
@@ -93,6 +94,8 @@ public class IoCodeTempController extends BaseController {
 
     @Resource
     IoOrderDetailBizService orderDetailBizService;
+    @Resource
+    IoCodeService codeService;
 
     //手持端扫码单据上传调用接口
     @AuthRuleAnnotation("")
@@ -464,33 +467,65 @@ public class IoCodeTempController extends BaseController {
         //校验预验收库存是否已存在
         if (bussinessTypeEntity.isScanPreIn()) {
 
+            if (bussinessTypeEntity.getBackPreinType() == 1) {//按单出库
 
+                String orderIds = bussinessTypeEntity.getCheckPreInOrders();
+                if (StrUtil.isNotEmpty(orderIds)) {
+                    String[] orderIdArray = StringUtils.split(",");
+                    List<String> orderList = CollUtil.toList(orderIdArray);
+                    int count = codeService.findByOrderIdsCount(orderList, code);
+                    if (count <= 0) {
+                        return ResultVOUtils.error(500, "预验收库存数量不足！");
+                    }
+                    if (StrUtil.isNotEmpty(orderId)) {//非首次添加
+                        if (StrUtil.isEmpty(udiEntity.getSerialNo())) {//该单据已有该产品
+                            //无序列号，则可能存在多个预验收入库单
+                            IoCodeTempEntity codeTempEntity = codeTempService.findByUnique(orderId, code);
+                            if (codeTempEntity != null) {
+                                if (count < (codeTempEntity.getMyCount() + 1)) {
+                                    return ResultVOUtils.error(500, "超出预验收库存数量");
+                                }
+                            }
+                        } else {
+                            if (count < 1) {
+                                return ResultVOUtils.error(500, "预验收库存数量不足");
+                            }
+                        }
+                    }
 
-            int preInCount = invPreinProductDetailService.findCountByCode(code);
+                } else {
-            InvPreInProductDetailEntity invPreinDetailEntity = invPreinProductDetailService.findUseOneByCode(code);
+                    return ResultVOUtils.error(500, "未选择预验收入库单，请先选择预验收入库单！");
-            if (preInCount <= 0) {
-                return ResultVOUtils.error(500, "预验收库存数量不足！");
-            } else {
-                if (StrUtil.isNotEmpty(invPreinDetailEntity.getBatchNo()) && StrUtil.isNotEmpty(addOrderRequest.getBatchNo())
-                        && !invPreinDetailEntity.getBatchNo().equals(addOrderRequest.getBatchNo())) {
-                    return ResultVOUtils.error(500, "当前批次号与预验收录入批次号不匹配！");
                 }
-                if (StrUtil.isNotEmpty(orderId)) {//非首次添加
+
-                    if (StrUtil.isEmpty(udiEntity.getSerialNo())) {//该单据已有该产品
+            } else {  //按库存出库
-                        //无序列号，则可能存在多个预验收入库单
+                int preInCount = invPreinProductDetailService.findCountByCode(code);
-                        IoCodeTempEntity codeTempEntity = codeTempService.findByUnique(orderId, code);
+                InvPreInProductDetailEntity invPreinDetailEntity = invPreinProductDetailService.findUseOneByCode(code);
-                        if (codeTempEntity != null) {
+                if (preInCount <= 0) {
-                            if (preInCount < (codeTempEntity.getMyCount() + 1)) {
+                    return ResultVOUtils.error(500, "预验收库存数量不足！");
-                                return ResultVOUtils.error(500, "超出预验收库存数量");
+                } else {
+                    if (StrUtil.isNotEmpty(invPreinDetailEntity.getBatchNo()) && StrUtil.isNotEmpty(addOrderRequest.getBatchNo())
+                            && !invPreinDetailEntity.getBatchNo().equals(addOrderRequest.getBatchNo())) {
+                        return ResultVOUtils.error(500, "当前批次号与预验收录入批次号不匹配！");
+                    }
+                    if (StrUtil.isNotEmpty(orderId)) {//非首次添加
+                        if (StrUtil.isEmpty(udiEntity.getSerialNo())) {//该单据已有该产品
+                            //无序列号，则可能存在多个预验收入库单
+                            IoCodeTempEntity codeTempEntity = codeTempService.findByUnique(orderId, code);
+                            if (codeTempEntity != null) {
+                                if (preInCount < (codeTempEntity.getMyCount() + 1)) {
+                                    return ResultVOUtils.error(500, "超出预验收库存数量");
+                                }
+                            }
+                        } else {
+                            if (preInCount < 1) {
+                                return ResultVOUtils.error(500, "预验收库存数量不足");
                             }
-                        }
-                    } else {
-                        if (preInCount < 1) {
-                            return ResultVOUtils.error(500, "预验收库存数量不足");
                         }
                     }
                 }
             }
+
+
         }
 
 

src/main/java/com/glxp/api/entity/basic/BasicBussinessTypeEntity.java

@@ -402,4 +402,6 @@ public class BasicBussinessTypeEntity {
     //    预验收剩余库存退库方式  1:按单使用或退库，2：按货位/仓库使用或退库
     @TableField(value = "backPreinType")
     private Integer backPreinType;
+    @TableField(value = "checkPreInOrders")
+    private String checkPreInOrders;
 }

src/main/java/com/glxp/api/req/basic/BussinessTypeSaveRequest.java

@@ -300,6 +300,7 @@ public class BussinessTypeSaveRequest {
     private boolean checkCertExpire;
     private String preInBackAction;
     private Integer backPreinType;
+    private String checkPreInOrders;
 
 
 }

src/main/java/com/glxp/api/res/basic/BasicBussinessTypeResponse.java

@@ -149,4 +149,5 @@ public class BasicBussinessTypeResponse {
     private boolean checkCertExpire;
     private String preInBackAction;
     private Integer backPreinType;
+    private String checkPreInOrders;
 }

src/main/java/com/glxp/api/service/inout/IoCheckInoutService.java

@@ -27,6 +27,7 @@ import com.glxp.api.util.OrderNoTypeBean;
 import com.glxp.api.util.udi.FilterUdiUtils;
 import com.glxp.api.util.udi.UdiCalCountUtil;
 import net.sf.jasperreports.engine.JRException;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
@@ -742,181 +743,74 @@ public class IoCheckInoutService {
     public void genInv(IoOrderEntity orderEntity, BasicBussinessTypeEntity bussinessTypeEntity) {
 
         if (bussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT) && bussinessTypeEntity.isScanPreIn()) {
-
             ThreadUtil.execAsync(() -> {
-                List<IoCodeEntity> backCodeList = new ArrayList<>();
+                if (StrUtil.isNotEmpty(bussinessTypeEntity.getPreInBackAction())) {
-                List<IoCodeEntity> codeList = codeService.findByOrderId(orderEntity.getBillNo());
+                    if (bussinessTypeEntity.getBackPreinType() == 1) {    //按单退货
-                for (IoCodeEntity codeEntity : codeList) {
+
-                    int count = invPreinProductDetailService.findCountByCode(codeEntity.getCode());
+                        String orderIds = bussinessTypeEntity.getCheckPreInOrders();
-                    if (count > 0) {
+                        if (StrUtil.isNotEmpty(orderIds)) {
-                        codeEntity.setCount(count);
+                            String[] orderIdArray = StringUtils.split(",");
-                        codeEntity.setReCount(udiCalCountUtil.getActCount(codeEntity.getNameCode()));
+                            List<String> orderList = CollUtil.toList(orderIdArray);
-                        backCodeList.add(codeEntity);
+                            List<IoCodeEntity> outCodeEntitys = codeService.findByOrderId(orderEntity.getBillNo());
-                    }
+                            List<IoCodeEntity> preInCodeEntities = codeService.findByOrderIds(orderList, null);
-                }
+
-                BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
+                            //                            扣减数量
-                if (StrUtil.isNotEmpty(basicBussinessTypeEntity.getPreInBackAction())) {
+                            for (IoCodeEntity preInCodeEntity : preInCodeEntities) {
-                    IoOrderEntity outOrder = new IoOrderEntity();
+                                for (IoCodeEntity codeEntity : outCodeEntitys) {
-//                    BeanUtils.copyProperties(orderEntity, outOrder);
+                                    if (preInCodeEntity.getCode().equals(codeEntity.getCode())) {
-                    outOrder.setId(null);
+                                        int count = preInCodeEntity.getMyCount() - codeEntity.getMyCount();
-                    outOrder.setMainAction(ConstantType.TYPE_OUT);
+                                        int reCount = preInCodeEntity.getMyReCount() - codeEntity.getMyReCount();
-                    outOrder.setAction(basicBussinessTypeEntity.getAction());
+
-                    outOrder.setCreateTime(new Date());
+                                        if (count > 0) {
-                    outOrder.setFromType(ConstantStatus.FROM_CHANGE);
+                                            preInCodeEntity.setCount(count);
-                    String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(basicBussinessTypeEntity.getPrefix()), "yyyyMMdd"));
+                                            preInCodeEntity.setReCount(reCount);
-                    outOrder.setBillNo(orderNo);
+                                            codeEntity.setCount(0);
-                    outOrder.setCustomerId(Constant.SYSTEM_CUSTOMER_ID);
+                                            codeEntity.setReCount(0);
-                    outOrder.setCorpOrderId(CustomUtil.getId() + "x");
+                                        } else if (count < 0) {
-                    outOrder.setStatus(ConstantStatus.ORDER_STATUS_PROCESS);
+                                            preInCodeEntity.setCount(0);
-                    orderEntity.setUllageSupNo(outOrder.getBillNo());
+                                            preInCodeEntity.setReCount(0);
-                    orderEntity.setUpdateTime(new Date());
+                                            codeEntity.setCount(-count);
-                    orderService.update(orderEntity);
+                                            codeEntity.setReCount(-reCount);
-                    outOrder.setOriginUllageSupNo(orderEntity.getBillNo());
+                                        } else {
-                    outOrder.setCreateUser(null);
+                                            preInCodeEntity.setCount(0);
-                    outOrder.setReviewUser(null);
+                                            preInCodeEntity.setReCount(0);
-                    orderService.insertOrder(outOrder);
+                                            codeEntity.setCount(0);
-
+                                            codeEntity.setReCount(0);
-                    //生成条码
+                                        }
-                    List<IoCodeTempEntity> codeTempEntities = new ArrayList<>();
+                                    }
-                    for (IoCodeEntity warehouseEntity : backCodeList) {
+                                }
-                        IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
+
-                        BeanUtils.copyProperties(warehouseEntity, codeTempEntity);
+                            }
-                        codeTempEntity.setId(null);
+
-                        codeTempEntity.setOrderId(outOrder.getBillNo());
+                            List<IoCodeEntity> backCodeList = new ArrayList<>();
-                        codeTempEntity.setAction(outOrder.getAction());
+                            for (IoCodeEntity codeEntity : preInCodeEntities) {
-                        codeTempEntity.setMainAction(outOrder.getMainAction());
+                                if (codeEntity.getMyCount() > 0) {
-                        codeTempEntity.setCreateTime(new Date());
+                                    backCodeList.add(codeEntity);
-                        codeTempEntity.setUpdateTime(new Date());
+                                }
-                        codeTempEntities.add(codeTempEntity);
+                            }
+                            genBackOrder(orderEntity, backCodeList);
+
+
+                        }
+
+
+                    } else {  //按仓库货位退货
+                        List<IoCodeEntity> backCodeList = new ArrayList<>();
+                        List<IoCodeEntity> codeList = codeService.findByOrderId(orderEntity.getBillNo());
+                        for (IoCodeEntity codeEntity : codeList) {
+                            int count = invPreinProductDetailService.findCountByCode(codeEntity.getCode());
+                            if (count > 0) {
+                                codeEntity.setCount(count);
+                                codeEntity.setReCount(udiCalCountUtil.getActCount(codeEntity.getNameCode()));
+                                backCodeList.add(codeEntity);
+                                genBackOrder(orderEntity, backCodeList);
+                            }
+                        }
                     }
-                    codeTempService.insertBatch(codeTempEntities);
-                    addInoutService.dealProcess(outOrder);
-                    if (!checkManual(outOrder.getBillNo())) {
-                        check(outOrder.getBillNo());
-                    }
-
-
                 }
-
-
-//                //找出UDI码对应的预验收入库单号
-//                Map<String, String> preInOrder = new HashMap<>();
-//                for (IoCodeEntity warehouseEntity : codeList) {
-//                    List<InvPreinDetailEntity> invProductDetailEntities = invPreinDetailService.findByCode(warehouseEntity.getCode());
-//                    if (invProductDetailEntities.size() > 0) {
-//                        for (InvPreinDetailEntity invPreinDetailEntity : invProductDetailEntities)
-//                            preInOrder.put(invPreinDetailEntity.getOrderId(), invPreinDetailEntity.getOrderId());
-//                    }
-//                }
-//                if (preInOrder.size() > 0) {
-//                    String preInBillNo = "";
-//                    boolean isBreak = false;
-//
-//                    for (String key : preInOrder.keySet()) {
-//                        if (!isBreak) {
-//                            preInBillNo = preInBillNo + "," + key;
-//                            IoOrderEntity preInEntity = orderService.findByBillNo(key);
-//                            preInEntity.setPreOutBillNo(orderEntity.getBillNo());
-//                            orderService.update(preInEntity);
-//                            BasicBussinessTypeEntity preBusType = basicBussinessTypeService.findByAction(preInEntity.getAction());
-//                            //预验收不删除单号，方便后续查询
-//                            if (preBusType.isPreInBack()) {            //预验收如果带回，则清空相关预验收库存；
-//                                invPreinDetailService.deleteByOrderId(preInEntity.getBillNo());
-//                                //剩余UDI码生成退货单 todo
-//                                List<IoCodeEntity> codeEntities = codeService.findByOrderId(key);
-//                                backCodeList.addAll(codeEntities);
-//                            } else {            //预验收如果不带回，则清除已出库相关库存
-//                                for (IoCodeEntity codeEntity : codeList) {
-//                                    if (StrUtil.isEmpty(codeEntity.getSerialNo())) {
-//                                        InvPreinDetailEntity invPreinDetailEntity = invPreinDetailService.findByCode(key, codeEntity.getCode());
-//                                        if (invPreinDetailEntity != null) {
-//                                            int count = 0;
-//                                            if (invPreinDetailEntity.getCount() < codeEntity.getCount()) {
-//                                                count = 0;
-//                                            } else {
-//                                                count = invPreinDetailEntity.getCount() - codeEntity.getCount();
-//                                            }
-//                                            if (count >= 0) {
-//                                                isBreak = true;
-//                                                if (count == 0) {
-//                                                    invPreinDetailService.deleteByCode(key, codeEntity.getCode());
-//                                                } else {
-//                                                    invPreinDetailEntity.setCount(count);
-//                                                    invPreinDetailService.update(invPreinDetailEntity);
-//                                                }
-//                                                int reCount = invPreinDetailEntity.getReCount() - codeEntity.getMyReCount();
-//                                                if (reCount == 0) {
-//                                                    invPreinDetailService.deleteByCode(key, codeEntity.getCode());
-//                                                } else {
-//                                                    invPreinDetailEntity.setReCount(reCount);
-//                                                    invPreinDetailService.update(invPreinDetailEntity);
-//                                                }
-//                                            }
-//                                        }
-//                                    } else {
-//                                        invPreinDetailService.deleteByCode(key, codeEntity.getCode());
-//                                    }
-//                                }
-//
-//                            }
-//                        }
-//
-//
-//                    }
-//                orderEntity.setPreInBillNo(preInBillNo.substring(1));
-//                orderService.update(orderEntity);
-//
-//
-//                //生成退货单 1.查出所有关联的单据条码，2.扣减当前出库数量；3.生成单据类型对应绑定的出库单
-//                if (CollUtil.isNotEmpty(backCodeList)) {
-//                    List<IoCodeEntity> realBackCodeList = new ArrayList<>();
-//                    for (IoCodeEntity backCodeEntity : backCodeList) {
-//                        for (IoCodeEntity codeEntity : codeList) {
-//                            if (codeEntity.getCount() != 0 && backCodeEntity.getCode().equals(codeEntity.getCode())) {
-//                                int count = backCodeEntity.getCount() - codeEntity.getCount();
-//                                int reCount = backCodeEntity.getReCount() - codeEntity.getReCount();
-//                                if (count > 0) {
-//                                    codeEntity.setCount(0);
-//                                    codeEntity.setReCount(0);
-//                                    backCodeEntity.setCount(count);
-//                                    backCodeEntity.setReCount(reCount);
-//                                    realBackCodeList.add(backCodeEntity);
-//                                } else if (count == 0) {
-//                                    codeEntity.setCount(0);
-//                                    codeEntity.setReCount(0);
-//                                } else if (count < 0) {
-//                                    codeEntity.setCount(-count);
-//                                    codeEntity.setReCount(-reCount);
-//                                }
-//                            }
-//                        }
-//
-//                    }
-//                    if (CollUtil.isNotEmpty(realBackCodeList)) {
-//                        Map<String, List<IoCodeEntity>> backPreInOrder = new HashMap<>();
-//                        for (IoCodeEntity codeEntity : codeList) {
-//                            List<IoCodeEntity> codeEntities = backPreInOrder.get(codeEntity.getOrderId());
-//                            if (CollUtil.isEmpty(codeEntities)) {
-//                                codeEntities = new ArrayList<>();
-//                            }
-//                            codeEntities.add(codeEntity);
-//                            backPreInOrder.put(codeEntity.getOrderId(), codeEntities);
-//                        }
-//
-//                        for (String key : backPreInOrder.keySet()) {
-//                            IoOrderEntity originOrder = orderService.findByBillNo(key);
-//                            BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeService.findByAction(originOrder.getAction());
-//
-//                        }
-//                    }
-//                }
-//            }
-
-
             });
         }
 
-
         //校验是否是不入库存单据
         if (bussinessTypeEntity.isInStock()) {
             //生成库存
@@ -931,10 +825,58 @@ public class IoCheckInoutService {
             //不入库存，直接进行单据流转
             changeInoutService.changeOrder(orderEntity);
         }
+    }
+
+
+    public void genBackOrder(IoOrderEntity orderEntity, List<IoCodeEntity> backCodeList) {
+        if (CollUtil.isEmpty(backCodeList))
+            return;
+        BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
+        if (StrUtil.isNotEmpty(basicBussinessTypeEntity.getPreInBackAction())) {
+            IoOrderEntity outOrder = new IoOrderEntity();
+            outOrder.setId(null);
+            outOrder.setMainAction(ConstantType.TYPE_OUT);
+            outOrder.setAction(basicBussinessTypeEntity.getAction());
+            outOrder.setCreateTime(new Date());
+            outOrder.setFromType(ConstantStatus.FROM_BACK);
+            String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(basicBussinessTypeEntity.getPrefix()), "yyyyMMdd"));
+            outOrder.setBillNo(orderNo);
+            outOrder.setCustomerId(Constant.SYSTEM_CUSTOMER_ID);
+            outOrder.setCorpOrderId(CustomUtil.getId() + "x");
+            outOrder.setStatus(ConstantStatus.ORDER_STATUS_PROCESS);
+            orderEntity.setUllageSupNo(outOrder.getBillNo());
+            orderEntity.setUpdateTime(new Date());
+            orderService.update(orderEntity);
+            outOrder.setOriginUllageSupNo(orderEntity.getBillNo());
+            outOrder.setCreateUser(null);
+            outOrder.setReviewUser(null);
+            orderService.insertOrder(outOrder);
+
+            //生成条码
+            List<IoCodeTempEntity> codeTempEntities = new ArrayList<>();
+            for (IoCodeEntity warehouseEntity : backCodeList) {
+                IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
+                BeanUtils.copyProperties(warehouseEntity, codeTempEntity);
+                codeTempEntity.setId(null);
+                codeTempEntity.setOrderId(outOrder.getBillNo());
+                codeTempEntity.setAction(outOrder.getAction());
+                codeTempEntity.setMainAction(outOrder.getMainAction());
+                codeTempEntity.setCreateTime(new Date());
+                codeTempEntity.setUpdateTime(new Date());
+                codeTempEntities.add(codeTempEntity);
+            }
+            codeTempService.insertBatch(codeTempEntities);
+            addInoutService.dealProcess(outOrder);
+            if (!checkManual(outOrder.getBillNo())) {
+                check(outOrder.getBillNo());
+            }
+
+        }
 
 
     }
 
+
     //   预验收使用出库处理1.不带回扣库存;2.带回时生成退货出库单
     @Resource
     GennerOrderUtils gennerOrderUtils;

src/main/java/com/glxp/api/service/inout/IoCodeService.java

@@ -21,6 +21,10 @@ public interface IoCodeService {
 
     public IoCodeEntity findByUnique(String orderId, String code);
 
+    List<IoCodeEntity> findByOrderIds(List<String> orderIds, String code);
+
+    int findByOrderIdsCount(List<String> orderIds, String code);
+
 
     boolean isExitByRelId(String relId);
 

src/main/java/com/glxp/api/service/inout/impl/IoCodeServiceImpl.java

@@ -1,6 +1,7 @@
 package com.glxp.api.service.inout.impl;
 
 import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.github.pagehelper.PageHelper;
@@ -66,6 +67,30 @@ public class IoCodeServiceImpl implements IoCodeService {
         return ioCodeDao.selectOne(new QueryWrapper<IoCodeEntity>().eq("orderId", orderId).eq("code", code));
     }
 
+    @Override
+    public List<IoCodeEntity> findByOrderIds(List<String> orderIds, String code) {
+
+        if (StrUtil.isNotEmpty(code))
+            return ioCodeDao.selectList(new QueryWrapper<IoCodeEntity>().eq("code", code).in("orderId", orderIds));
+        else {
+            return ioCodeDao.selectList(new QueryWrapper<IoCodeEntity>().in("orderId", orderIds));
+        }
+    }
+
+    @Override
+    public int findByOrderIdsCount(List<String> orderIds, String code) {
+        List<IoCodeEntity> codeEntities = findByOrderIds(orderIds, code);
+        if (CollUtil.isNotEmpty(codeEntities)) {
+            int count = 0;
+            for (IoCodeEntity codeEntity : codeEntities) {
+                count = count + codeEntity.getMyCount();
+            }
+
+            return count;
+        }
+        return 0;
+    }
+
     @Override
     public boolean isExitByRelId(String relId) {
 //        return ioCodeDao.selectList(new QueryWrapper<IoCodeEntity>().eq("relId", relId).last("limit 1"));

src/main/resources/mybatis/mapper/basic/BasicBussinessTypeDao.xml

@@ -58,7 +58,7 @@
 
     <insert id="insertIgnoreBussinessType" parameterType="com.glxp.api.entity.basic.BasicBussinessTypeEntity">
         insert
-            ignore
+                ignore
         into basic_bussiness_type (mainAction, action, name, enable, remark, thirdSysFk, genUnit, innerOrder,
                                    secCheckEnable, checkEnable, checkUdims, checkPdaEd, checkPdaUn, checkPc,
                                    checkWebNew, checkSp, checkChange, secCheckUdims, secCheckPdaEd, secCheckPdaUn,
@@ -70,7 +70,7 @@
                                    vailGroupBuy, busType, inStock, actionType, thrCheckEnable, thrCheckWebNew,
                                    thrCheckPdaUn, thrCheckPdaEd, thrCheckUdims, thrCheckPc, thrCheckSp,
                                    thrCheckChange, thrCheckBalance, thrCheckCopy, fillCodeRel, checkVailDate,
-                                   checkExpire, checkCertExpire,preInBackAction,    backPreinType)
+                                   checkExpire, checkCertExpire, preInBackAction, backPreinType, checkPreInOrders)
         values (#{mainAction}, #{action}, #{name}, #{enable}, #{remark}, #{thirdSysFk}, #{genUnit}, #{innerOrder},
                 #{secCheckEnable}, #{checkEnable}, #{checkUdims}, #{checkPdaEd}, #{checkPdaUn}, #{checkPc},
                 #{checkWebNew}, #{checkSp}, #{checkChange}, #{secCheckUdims}, #{secCheckPdaEd}, #{secCheckPdaUn},
@@ -82,7 +82,7 @@
                 #{vailGroupBuy}, #{busType}, #{inStock}, #{actionType}, #{thrCheckEnable}, #{thrCheckWebNew},
                 #{thrCheckPdaUn}, #{thrCheckPdaEd}, #{thrCheckUdims}, #{thrCheckPc}, #{thrCheckSp},
                 #{thrCheckChange}, #{thrCheckBalance}, #{thrCheckCopy}, #{fillCodeRel}, #{checkVailDate},
-                #{checkExpire}, #{checkCertExpire},#{preInBackAction},#{backPreinType})
+                #{checkExpire}, #{checkCertExpire}, #{preInBackAction}, #{backPreinType}, #{checkPreInOrders})
     </insert>
 
     <select id="selectBusList" resultType="com.glxp.api.entity.basic.BasicBussinessTypeEntity">
@@ -148,13 +148,13 @@
         where mainAction = #{mainAction}
           and corpType = 3
           and (supplementOrderType is null
-            or supplementOrderType = '')
+                or supplementOrderType = '')
     </select>
 
     <select id="selectByUser" resultType="com.glxp.api.entity.basic.BasicBussinessTypeEntity">
         select basic_bussiness_type.*
         from basic_bussiness_type
-                 inner join auth_user_bustype on basic_bussiness_type.action = auth_user_bustype.scAction
+                     inner join auth_user_bustype on basic_bussiness_type.action = auth_user_bustype.scAction
         <where>
             <if test="name != null and name != ''">
                 AND basic_bussiness_type.name like concat('%', #{name}, '%')
@@ -185,7 +185,7 @@
             resultType="com.glxp.api.res.basic.BasicBussinessTypeResponse">
         SELECT basic_bussiness_type.*
         FROM basic_bussiness_type
-                 left JOIN auth_user_bustype ON basic_bussiness_type.action = auth_user_bustype.scAction
+                     left JOIN auth_user_bustype ON basic_bussiness_type.action = auth_user_bustype.scAction
         <where>
             <if test="name != ''and name != null">
                 AND basic_bussiness_type.name LIKE concat('%', #{name}, '%')
@@ -223,7 +223,7 @@
             resultType="com.glxp.api.res.basic.BasicBussinessTypeResponse">
         SELECT basic_bussiness_type.*
         FROM basic_bussiness_type
-                 left JOIN auth_warehouse_bustype ON basic_bussiness_type.action = auth_warehouse_bustype.action
+                     left JOIN auth_warehouse_bustype ON basic_bussiness_type.action = auth_warehouse_bustype.action
         <where>
             <if test="name != ''and name != null">
                 AND basic_bussiness_type.name LIKE concat('%', #{name}, '%')