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

package com.glxp.api.service.inout;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.pagehelper.PageHelper;
import com.glxp.api.entity.basic.SysWorkplaceDocumentEntity;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoCodeEntity;
import com.glxp.api.req.inout.IoSplitFifoInvRequest;
import com.glxp.api.res.inout.IoSplitInvResponse;
import com.glxp.api.service.basic.SysWorkplaceDocumentService;
import com.glxp.api.util.IntUtil;
import org.apache.xpath.operations.Bool;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.glxp.api.entity.inout.IoSplitFifoInv;
import com.glxp.api.dao.inout.IoSplitFifoInvMapper;
import org.springframework.transaction.annotation.Transactional;

@Service
public class IoSplitFifoInvService extends ServiceImpl<IoSplitFifoInvMapper, IoSplitFifoInv> {

    @Resource
    IoSplitFifoCodeService splitFifoCodeService;
    @Resource
    SysWorkplaceDocumentService sysWorkplaceDocumentService;

    /**
     * 插入库存
     *
     * @param codeList
     * @param workPlaceCode
     * @param busType
     */
    @Transactional(rollbackFor = Exception.class)
    public void insertInv(List<IoCodeEntity> codeList, Long workPlaceCode, String busType) {

        List<IoSplitFifoCodeEntity> splitCodeEntities = new ArrayList<>();
        if (CollUtil.isNotEmpty(codeList)) {
            for (IoCodeEntity codeEntity : codeList) {
                IoSplitFifoCodeEntity ioSplitFifoCodeEntity = null;
                if (StrUtil.isEmpty(codeEntity.getSerialNo())) {
                    ioSplitFifoCodeEntity = splitFifoCodeService.findByCode(codeEntity.getCode(), workPlaceCode);
                }
                if (ioSplitFifoCodeEntity != null) {
                    ioSplitFifoCodeEntity.setScanCount(IntUtil.value(ioSplitFifoCodeEntity.getScanCount()) + IntUtil.value(codeEntity.getCount()));
                    ioSplitFifoCodeEntity.setTotalCount(ioSplitFifoCodeEntity.getTotalCount() + codeEntity.getReCount());
                    ioSplitFifoCodeEntity.setUpdateTime(new Date());
                    ioSplitFifoCodeEntity.setBusType(busType);
                    splitFifoCodeService.updateById(ioSplitFifoCodeEntity);
                } else {
                    IoSplitFifoCodeEntity splitCodeEntity = new IoSplitFifoCodeEntity();
                    BeanUtils.copyProperties(codeEntity, splitCodeEntity);
                    splitCodeEntity.setInBactchNo(codeEntity.getInBatchNo());
                    splitCodeEntity.setScanCount(codeEntity.getCount());
                    splitCodeEntity.setTotalCount(IntUtil.value(splitCodeEntity.getTotalCount()) + codeEntity.getReCount());
                    splitCodeEntity.setSupId(Long.parseLong(codeEntity.getSupId()));
                    splitCodeEntity.setWorkPlaceCode(workPlaceCode);
                    splitCodeEntity.setFifoSplit(codeEntity.getFifoSplit());
                    splitCodeEntity.setBusType(busType);
                    splitCodeEntity.setId(null);
                    splitCodeEntities.add(splitCodeEntity);
                }
            }
        }

        for (IoSplitFifoCodeEntity ioSplitFifoCodeEntity : splitCodeEntities) {
            Boolean isOnlyInv = sysWorkplaceDocumentService.isOnlyInv(ioSplitFifoCodeEntity.getWorkPlaceCode(), ioSplitFifoCodeEntity.getBusType());
            IoSplitFifoInv splitFifoInv = findByFifoCode(ioSplitFifoCodeEntity);
            if (splitFifoInv != null) {
                splitFifoInv.setInCount(IntUtil.value(splitFifoInv.getInCount()) + IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()));
                splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getAvailableCount()) + IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()));
                updateById(splitFifoInv);
            } else {
                splitFifoInv = IoSplitFifoInv.builder()
                        .id(IdUtil.getSnowflakeNextId())
                        .workPlaceCode(ioSplitFifoCodeEntity.getWorkPlaceCode())
                        .deptCode(ioSplitFifoCodeEntity.getDeptCode())
                        .invCode(ioSplitFifoCodeEntity.getInvCode())
                        .productType(ioSplitFifoCodeEntity.getProductType())
                        .fifoSplit(ioSplitFifoCodeEntity.getFifoSplit())
                        .relId(ioSplitFifoCodeEntity.getRelId())
                        .batchNo(ioSplitFifoCodeEntity.getBatchNo())
                        .produceDate(ioSplitFifoCodeEntity.getProduceDate())
                        .expireDate(ioSplitFifoCodeEntity.getExpireDate())
                        .supId(ioSplitFifoCodeEntity.getSupId())
                        .inCount(ioSplitFifoCodeEntity.getTotalCount())
                        .outCount(0)
                        .reCount(IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()))
                        .availableCount(IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()))
                        .lockCount(0)
                        .createTime(new Date())
                        .updateTime(new Date())
                        .remark(null)
                        .enableRemind(false)
                        .invRemindCount(0).build();
                if (isOnlyInv) {
                    splitFifoInv.setBusType(ioSplitFifoCodeEntity.getBusType());
                }
                save(splitFifoInv);
            }
            ioSplitFifoCodeEntity.setInvIdFk(splitFifoInv.getId());
        }

        splitFifoCodeService.saveBatch(splitCodeEntities);
    }

    /**
     * 移除库存
     *
     * @param codeList
     * @param workPlaceCode
     */
    @Transactional(rollbackFor = Exception.class)
    public void removeInv(List<IoCodeEntity> codeList, Long workPlaceCode) {
        List<IoSplitFifoCodeEntity> splitCodeEntities = new ArrayList<>();
        if (CollUtil.isNotEmpty(codeList)) {
            for (IoCodeEntity codeEntity : codeList) {
                IoSplitFifoCodeEntity ioSplitFifoCodeEntity = splitFifoCodeService.findByCode(codeEntity.getCode(), workPlaceCode);
                if (StrUtil.isEmpty(codeEntity.getSerialNo())) {
                    if (ioSplitFifoCodeEntity != null) {
                        ioSplitFifoCodeEntity.setScanCount(IntUtil.value(ioSplitFifoCodeEntity.getScanCount()) - IntUtil.value(codeEntity.getCount()));
                        ioSplitFifoCodeEntity.setTotalCount(ioSplitFifoCodeEntity.getTotalCount() + codeEntity.getReCount());
                        ioSplitFifoCodeEntity.setUpdateTime(new Date());
                        splitFifoCodeService.updateById(ioSplitFifoCodeEntity);
                    }
                } else {
                    splitCodeEntities.add(ioSplitFifoCodeEntity);
                }
            }
        }
        splitFifoCodeService.removeBatchByIds(splitCodeEntities);
        for (IoSplitFifoCodeEntity ioSplitFifoCodeEntity : splitCodeEntities) {
            IoSplitFifoInv splitFifoInv = findByFifoCode(ioSplitFifoCodeEntity);
            if (splitFifoInv != null) {
                splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(ioSplitFifoCodeEntity.getTotalCount()));
                splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                updateById(splitFifoInv);
            }
        }

    }


    public IoSplitFifoInv findByFifoCode(IoSplitFifoCodeEntity ioSplitFifoCodeEntity) {
        Boolean isOnlyInv = sysWorkplaceDocumentService.isOnlyInv(ioSplitFifoCodeEntity.getWorkPlaceCode(), ioSplitFifoCodeEntity.getBusType());
        IoSplitFifoInv splitFifoInv = getOne(new LambdaQueryWrapper<IoSplitFifoInv>()
                .eq(IoSplitFifoInv::getRelId, ioSplitFifoCodeEntity.getRelId())
                .eq(IoSplitFifoInv::getWorkPlaceCode, ioSplitFifoCodeEntity.getWorkPlaceCode())
                .eq(StrUtil.isNotEmpty(ioSplitFifoCodeEntity.getBatchNo()), IoSplitFifoInv::getBatchNo, ioSplitFifoCodeEntity.getBatchNo())
                .eq(StrUtil.isNotEmpty(ioSplitFifoCodeEntity.getBusType()) && isOnlyInv, IoSplitFifoInv::getBusType, ioSplitFifoCodeEntity.getBusType())
                .eq(ioSplitFifoCodeEntity.getSupId() != null, IoSplitFifoInv::getSupId, ioSplitFifoCodeEntity.getSupId()).last("limit 1"));

        return splitFifoInv;
    }

    /**
     * 库存查询
     * 若开启了库存预警，需要在库存上有一个状态显示预警状态   1:正常；2:低库存；3:负库存
     *
     * @param ioSplitFifoInvRequest
     * @return
     */
    public List<IoSplitInvResponse> filterList(IoSplitFifoInvRequest ioSplitFifoInvRequest) {
        if (ioSplitFifoInvRequest == null) {
            return Collections.emptyList();
        }
        if (ioSplitFifoInvRequest.getPage() != null) {
            int offset = (ioSplitFifoInvRequest.getPage() - 1) * ioSplitFifoInvRequest.getLimit();
            PageHelper.offsetPage(offset, ioSplitFifoInvRequest.getLimit());
        }
        List<IoSplitInvResponse> ioSplitInvResponses = this.baseMapper.filterList(ioSplitFifoInvRequest);
        if (CollUtil.isNotEmpty(ioSplitInvResponses)) {
            ioSplitInvResponses.forEach(t -> {
                if (t.getEnableRemind()) {
                    int count = t.getReCount() - t.getInvRemindCount();
                    if (count >= 0) {
                        t.setRemindState(1);
                    } else {
                        t.setRemindState(2);
                    }
                } else {
                    t.setRemindState(1);
                }
            });
            return ioSplitInvResponses;
        } else {
            return Collections.emptyList();
        }
    }

    /**
     * 库存预警设置
     *
     * @param ioSplitFifoInvRequest
     */
    @Transactional(rollbackFor = Exception.class)
    public void remindSet(IoSplitFifoInvRequest ioSplitFifoInvRequest) {
        Assert.notNull(ioSplitFifoInvRequest.getId(), "Id不能为空");
        IoSplitFifoInv old = this.getById(ioSplitFifoInvRequest.getId());
        Assert.notNull(old, "不存在该库存预警设置");
        this.lambdaUpdate()
                .set(ioSplitFifoInvRequest.getEnableRemind() != null, IoSplitFifoInv::getEnableRemind, ioSplitFifoInvRequest.getEnableRemind() ? 1 : 0)
                .set(ioSplitFifoInvRequest.getInvRemindCount() != null, IoSplitFifoInv::getInvRemindCount, ioSplitFifoInvRequest.getInvRemindCount())
                .set(IoSplitFifoInv::getUpdateTime, new Date())
                .eq(IoSplitFifoInv::getId, ioSplitFifoInvRequest.getId())
                .update();
    }

}