udi-wms-java/src/main/java/com/glxp/api/service/inout/IoGenInvService.java

package com.glxp.api.service.inout;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.basic.BasicBusTypePreEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.UdiRelevanceEntity;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderDetailResultEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.InvPreinDetailEntity;
import com.glxp.api.entity.inv.InvPreinOrderEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.basic.IBasicBusTypePreService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inv.InvPreinDetailService;
import com.glxp.api.service.inv.InvPreinOrderService;
import com.glxp.api.service.inv.InvProductDetailService;
import com.glxp.api.service.inv.InvProductService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.CustomUtil;
import com.glxp.api.util.DateUtil;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.OrderNoTypeBean;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;


@Service
public class IoGenInvService {


    @Resource
    InvProductService invProductService;
    @Resource
    InvProductDetailService invProductDetailService;
    @Resource
    InvPreinOrderService invPreinOrderService;
    @Resource
    InvPreinDetailService invPreinDetailService;
    @Resource
    IBasicBussinessTypeService basicBussinessTypeService;
    @Resource
    IoOrderService orderService;
    @Resource
    IoOrderDetailResultService orderDetailResultService;
    @Resource
    IoCodeService codeService;
    @Resource
    IBasicBusTypePreService basicBusTypePreService;
    @Resource
    GennerOrderUtils gennerOrderUtils;
    @Resource
    InvWarehouseService invWarehouseService;
    @Resource
    SystemParamConfigService systemParamConfigService;
    @Resource
    IoCodeTempService codeTempService;


    //生成普通库存
    public void genNorInv(String orderId) {
        IoOrderEntity orderEntity = orderService.findByBillNo(orderId);
        List<IoOrderDetailResultEntity> orderDetailResultEntities = orderDetailResultService.findByOrderId(orderId);
        List<IoCodeEntity> codeEnttities = codeService.findByOrderId(orderId);

        //生成库存产品表
        List<InvProductEntity> invProductEntities = new ArrayList<>();
        for (IoOrderDetailResultEntity orderDetailResultEntity : orderDetailResultEntities) {
            InvProductEntity invProductEntity = invProductService.selectByUnique(orderDetailResultEntity.getBindRlFk(), orderDetailResultEntity.getBatchNo(), orderDetailResultEntity.getSupId(), orderEntity.getDeptCode(), orderEntity.getInvCode());
            if (invProductEntity == null) {
                invProductEntity = new InvProductEntity();
                invProductEntity.setRelIdFk(orderDetailResultEntity.getBindRlFk());
                invProductEntity.setNameCode(orderDetailResultEntity.getNameCode());
                invProductEntity.setBatchNo(orderDetailResultEntity.getBatchNo());
                invProductEntity.setProductionDate(orderDetailResultEntity.getProductDate());
                invProductEntity.setExpireDate(orderDetailResultEntity.getExpireDate());
                invProductEntity.setInCount(0);
                invProductEntity.setOutCount(0);
                invProductEntity.setSupId(orderDetailResultEntity.getSupId());
                invProductEntity.setDeptCode(orderEntity.getDeptCode());
                invProductEntity.setInvCode(orderEntity.getInvCode());
                invProductEntity.setCreateTime(new Date());
                invProductEntity.setUpdateTime(new Date());
                invProductService.insert(invProductEntity);
            }

            if (orderEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
                invProductEntity.setOutCount(invProductEntity.getOutCount() + orderDetailResultEntity.getReCount());
            } else if (orderEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
                invProductEntity.setInCount(invProductEntity.getInCount() + orderDetailResultEntity.getReCount());
            }
            invProductEntity.setReCount(invProductEntity.getInCount() - invProductEntity.getOutCount());
            invProductEntity.setUpdateTime(new Date());
            invProductService.update(invProductEntity);
        }

        //生成库存码详情
        List<InvProductDetailEntity> invProductDetailEntities = new ArrayList<>();
        for (IoCodeEntity codeEntity : codeEnttities) {
            InvProductDetailEntity invProductDetailEntity = new InvProductDetailEntity();
            BeanUtils.copyProperties(codeEntity, invProductDetailEntity);
            invProductDetailEntity.setRelId(codeEntity.getRelId());
            invProductDetailEntity.setUpdateTime(new Date());
            invProductDetailEntity.setPurchaseType(ConstantStatus.PRUCHASE_COMMON);
            invProductDetailEntities.add(invProductDetailEntity);
        }
        BasicBusTypePreEntity basicBusTypePreEntity = basicBusTypePreService.findByOriginAction(orderEntity.getAction());
        if (basicBusTypePreEntity != null) {        //进行单据流转
            genNewOrder(orderEntity, invProductDetailEntities);
        } else {        //生成库存结束
            invProductDetailService.insertList(invProductDetailEntities);
        }


    }


    //生成预验收库存
    public void genPreInInv(String orderId) {
        IoOrderEntity orderEntity = orderService.findByBillNo(orderId);
        InvPreinOrderEntity invPreinOrderEntity = new InvPreinOrderEntity();
        BeanUtils.copyProperties(orderEntity, invPreinOrderEntity);
        invPreinOrderService.insert(invPreinOrderEntity);

        List<IoCodeEntity> codeEnttities = codeService.findByOrderId(orderId);
        List<InvPreinDetailEntity> invPreinDetailEntities = new ArrayList<>();
        codeEnttities.forEach(codeEntity ->
        {
            InvPreinDetailEntity invPreinDetailEntity = new InvPreinDetailEntity();
            BeanUtils.copyProperties(codeEntity, invPreinDetailEntity);
            invPreinDetailEntity.setId(null);
            invPreinDetailEntities.add(invPreinDetailEntity);
        });

        invPreinDetailService.insertList(invPreinDetailEntities);

    }


    //单据流转
    public void genNewOrder(IoOrderEntity orderEntity, List<InvProductDetailEntity> invProductDetailEntities) {

        BasicBusTypePreEntity basicBusTypePreEntity = basicBusTypePreService.findByOriginAction(orderEntity.getAction());
        List<IoCodeEntity> codeEnttities = codeService.findByOrderId(orderEntity.getBillNo());
        if (basicBusTypePreEntity.getSupplementAll()) {//全量补单
            invProductDetailService.insertList(invProductDetailEntities);
            buildInOrder(basicBusTypePreEntity, codeEnttities, orderEntity);
        } else {    //缺量补单
            List<IoCodeEntity> inList = new ArrayList<>();
            for (IoCodeEntity warehouseEntity : codeEnttities) {
                Integer invCount = getInvCount(warehouseEntity);
                Integer count = warehouseEntity.getReCount();
                if (invCount > 0) {//仓库已存在该产品
                    if (count > invCount) { //当前数量>结余数量，说明该产品是无序列号或者是多级包装
                        if (count > invCount) {      //该产品实际数量大于结余数量，说明是多级包装，直接补
                            inList.add(warehouseEntity);
                        } else if (warehouseEntity.getSerialNo() == null) { //无序列号（多级包装无序列号的已在上一步被排除），补齐数量
                            int lea = count - invCount;
                            warehouseEntity.setCount(lea / (count));  //
                            inList.add(warehouseEntity);
                        }
                    }
                } else {        //结余数量《=0直接补
                    inList.add(warehouseEntity);
                }
                InvProductDetailEntity invProductDetailEntity = filterInvByCode(invProductDetailEntities, warehouseEntity.getCode());
                invProductDetailService.insert(invProductDetailEntity);
            }
            buildInOrder(basicBusTypePreEntity, inList, orderEntity);
        }
    }


    public InvProductDetailEntity filterInvByCode(List<InvProductDetailEntity> invProductDetailEntities, String
            code) {
        for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
            if (invProductDetailEntity.getCode().equals(code)) {
                return invProductDetailEntity;
            }
        }
        return null;
    }


    //生成单据
    public void buildInOrder(BasicBusTypePreEntity bussinessChangeTypeEntity, List<IoCodeEntity> useInList, IoOrderEntity orderEntity) {
        if (useInList.size() <= 0) {
            return;
        }
        Map<String, List<IoCodeEntity>> filterSupMaps = new HashMap<>();
        BasicBussinessTypeEntity targetBustypeEntity = basicBussinessTypeService.findByAction(bussinessChangeTypeEntity.getAction());
        //过滤供应商
        if (targetBustypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_OUT) {
            for (IoCodeEntity warehouseEntity : useInList) {
                if (warehouseEntity.getSupId() != null) {
                    if (filterSupMaps.get(warehouseEntity.getSupId()) == null) {
                        List<IoCodeEntity> temps = new ArrayList<>();
                        temps.add(warehouseEntity);
                        filterSupMaps.put(warehouseEntity.getSupId(), temps);
                    } else {
                        filterSupMaps.get(warehouseEntity.getSupId()).add(warehouseEntity);
                    }
                }
            }
        } else {
            filterSupMaps.put(bussinessChangeTypeEntity.getDefaultInvCode(), useInList);
        }
        //根据往来单位生成入库单
        for (String corpName : filterSupMaps.keySet()) {
            List<IoCodeEntity> temps;
            temps = filterSupMaps.get(corpName);
            IoOrderEntity outOrder = new IoOrderEntity();
            BeanUtils.copyProperties(orderEntity, outOrder);
            outOrder.setId(null);
            outOrder.setSupplementNo(null);//补单需置空
            outOrder.setCreateTime(DateUtil.getBeforeDay(DateUtil.fromDate(orderEntity), bussinessChangeTypeEntity.getBeforeTime()));
            outOrder.setAction(targetBustypeEntity.getAction());
            outOrder.setMainAction(targetBustypeEntity.getMainAction());

            outOrder.setFromType(ConstantStatus.FROM_CHANGE);
            String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(targetBustypeEntity.getPrefix()), "yyyyMMdd"));
            outOrder.setBillNo(orderNo);

            if (targetBustypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_OUT) {
                outOrder.setCustomerId(corpName);
                outOrder.setFromCorp(corpName);
                outOrder.setFromInvCode(null);
                outOrder.setFromDeptCode(null);
            } else {
                outOrder.setCustomerId(Constant.SYSTEM_CUSTOMER_ID);
                outOrder.setFromInvCode(bussinessChangeTypeEntity.getDefaultInvCode());
                outOrder.setFromDeptCode(bussinessChangeTypeEntity.getDefaultDeptCode());
                outOrder.setFromCorp(null);
            }
            outOrder.setCorpOrderId(CustomUtil.getId() + "x");
            InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(bussinessChangeTypeEntity.getInvCode());
            outOrder.setInvCode(invWarehouseEntity.getCode());
            outOrder.setDeptCode(invWarehouseEntity.getParentId());
            SystemParamConfigEntity systemParamConfigEntity = systemParamConfigService.selectByParamKey("additional_auto_submit");
            if ("1".equals(systemParamConfigEntity.getParamValue())) {
                outOrder.setStatus(ConstantStatus.ORDER_STATUS_PROCESS);
            } else {
                outOrder.setStatus(ConstantStatus.ORDER_STATUS_ADDITIONAL);
            }

            //互填单号
            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 : temps) {
                IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
                BeanUtils.copyProperties(warehouseEntity, codeTempEntity);
                codeTempEntity.setId(null);
                codeTempEntity.setOrderId(outOrder.getBillNo());
                codeTempEntity.setAction(outOrder.getAction());
                codeTempEntity.setMainAction(outOrder.getMainAction());
                codeTempEntities.add(codeTempEntity);
            }
            codeTempService.insertBatch(codeTempEntities);
            addInoutService.dealProcess(outOrder);
        }
    }

    @Resource
    IoAddInoutService addInoutService;


    //计算当前库存数量
    public int getInvCount(IoCodeEntity codeEntity) {

        List<InvProductDetailEntity> resultLists = invProductDetailService.selectByUnique(codeEntity.getRelId(), codeEntity.getBatchNo(), codeEntity.getSupId(), codeEntity.getDeptCode(), codeEntity.getInvCode());
        int invCount = 0;
        if (CollUtil.isNotEmpty(resultLists)) {
            for (InvProductDetailEntity invProductDetailEntity : resultLists) {
                if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
                    invCount = invCount - invProductDetailEntity.getCount();
                } else {
                    invCount = invCount + invProductDetailEntity.getCount();
                }
            }
        }
        return invCount;
    }


}