wms / hhwms · Files

package com.huaheng.pc.shipment.shipmentHeader.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.common.exception.service.ServiceException;

import com.huaheng.common.support.Convert;

import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService;

import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;

import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;

import com.huaheng.pc.shipment.shipmentDetailHistory.domain.ShipmentDetailHistory;
import com.huaheng.pc.shipment.shipmentDetailHistory.service.ShipmentDetailHistoryService;
import com.huaheng.pc.shipment.shipmentHeaderHistory.domain.ShipmentHeaderHistory;
import com.huaheng.pc.shipment.shipmentHeaderHistory.service.ShipmentHeaderHistoryService;

import com.huaheng.pc.system.dict.service.IDictDataService;

import org.apache.commons.beanutils.BeanUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;
import javax.annotation.Resource;

import java.lang.reflect.InvocationTargetException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.Map;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.mapper.ShipmentHeaderMapper;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;

import org.springframework.transaction.annotation.Transactional;

@Service

public class ShipmentHeaderServiceImpl extends ServiceImpl<ShipmentHeaderMapper, ShipmentHeader> implements ShipmentHeaderService{

    @Autowired
    private IDictDataService dictDataService;
    @Resource
    private ShipmentHeaderMapper shipmentHeaderMapper;

    @Autowired
    private ShipmentDetailService shipmentDetailService;
    @Autowired
    private ShipmentContainerHeaderService shipmentContainerHeaderService;

    @Autowired
    private ShipmentHeaderHistoryService shipmentHeaderHistoryService;
    @Autowired
    private ShipmentDetailHistoryService shipmentDetailHistoryService;

    //新增出库主单
    @Override
    public AjaxResult<Boolean> saveHeader(ShipmentHeader shipmentHeader) {
        if(dictDataService.checkConfig("shipmentType", shipmentHeader.getShipmentType()) == false)
        {
            return  AjaxResult.error("没有对应的出库单类型");
        }
        String code = createCode(shipmentHeader.getShipmentType());
        shipmentHeader.setId(null);
        shipmentHeader.setFirstStatus(0);
        shipmentHeader.setLastStatus(0);
        shipmentHeader.setLastUpdated(null);
        shipmentHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
        shipmentHeader.setCreated(null);
        shipmentHeader.setCreatedBy(ShiroUtils.getLoginName());
        shipmentHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        shipmentHeader.setCode(code);
        boolean result = this.save(shipmentHeader);
        return  AjaxResult.toAjax(result);
    }


    //根据单据类型建单据号
    public String createCode(String shipmentType)
    {
        String code = null;
        Date now = new Date();
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
        String maxCode = shipmentHeaderMapper.createCode(shipmentType);
        if (maxCode != null && maxCode.length() > 13 && maxCode.substring(maxCode.length() - 13, maxCode.length() - 5).equals(df.format(now)))
        {
            Integer Count = Integer.valueOf(maxCode.substring(maxCode.length() - 5, maxCode.length()));
            code = shipmentType + df.format(now) + String.format("%05d", Count + 1);
        }
        else
        {
            code = shipmentType + df.format(now) + "00001";
        }
        return code;
    }

    /**
     * 根据Id更新这个单据的首尾状态
     * @param shipmentId
     * @return
     */
    @Override
    public AjaxResult updateShipmentStatus(int shipmentId)  {
        //获取这个单
        ShipmentHeader shipmentHeader = this.getById(shipmentId);
        if(shipmentHeader==null){
            return AjaxResult.error("单据未找到，Id:"+shipmentId);
        }
        //查询是否有生成出库货箱,如果有，则返回出库货箱的最高与最低状态
        Map<String,Integer> map = shipmentContainerHeaderService.getShipmentContainerMaxAndMinStatusByShipmentID(shipmentId);
        if(map==null){
            //说明没有货箱，则直接首位均为新建

            shipmentHeader.setFirstStatus(100);
            shipmentHeader.setLastStatus(100);

            this.saveOrUpdate(shipmentHeader);
        }else {
            int firstStatus = map.get("maxStatus");
            int lastStatus = map.get("minStatus");

            if(firstStatus<=20){

                shipmentHeader.setFirstStatus(300);
            }
            if(firstStatus==30){
                shipmentHeader.setFirstStatus(500);
            }

            if(lastStatus <=20){

                shipmentHeader.setLastStatus(300);
            }
            if(lastStatus==30){
                shipmentHeader.setLastStatus(500);
            }
            //是否存在未配盘的数量，如果是，则尾状态为新建
            Integer UnCompleted = shipmentDetailService.countUnCompleted(shipmentId);
            if(UnCompleted != null && UnCompleted.intValue() > 0){

                shipmentHeader.setLastStatus(100);

            }
            this.saveOrUpdate(shipmentHeader);
        }

        return AjaxResult.success("");

    }

    //出库单字段变为历史出库单
    @Override
    @Transactional
    public AjaxResult addHistory(ShipmentHeader shipmentHeader) throws InvocationTargetException, IllegalAccessException {
        //历史出库主单
        ShipmentHeaderHistory shipmentHeaderHistory=new ShipmentHeaderHistory();
        BeanUtils.copyProperties(shipmentHeaderHistory,shipmentHeader);
        if(shipmentHeaderHistoryService.save(shipmentHeaderHistory)==false){
            throw new ServiceException("存入历史出库主单失败");
        }
        LambdaQueryWrapper<ShipmentDetail> lambdaQueryWrapper=Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ShipmentDetail::getWarehouseCode,shipmentHeader.getWarehouseCode())
                .eq(ShipmentDetail::getShipmentCode,shipmentHeader.getCode());
        List<ShipmentDetail> shipmentDetails=shipmentDetailService.list(lambdaQueryWrapper);

        //历史出库子单
        List<ShipmentDetailHistory> shipmentDetailHistories=new ArrayList<>();
        for(ShipmentDetail item:shipmentDetails){
            ShipmentDetailHistory shipmentDetailHistory=new ShipmentDetailHistory();
            BeanUtils.copyProperties(shipmentDetailHistory,item);
            shipmentDetailHistories.add(shipmentDetailHistory);
        }
        Boolean flag=shipmentDetailHistoryService.saveBatch(shipmentDetailHistories);
        if(flag==false){
            throw new ServiceException("存入历史出库子单失败");
        }
        return null;
    }

    /**审核出库单，加入订单池
     * 1、找到主单，确定主单的状态是否小于100
     * 2.小于100时，把主单和相应的子单加入到list中，大于等于100时，直接跳过
     * 3.将修改后的主单列表和子单列表进行修改，加入订单池
     *
     * @param ids
     * @return
     */

    @Override
    public AjaxResult review(String ids) {

        List<ShipmentHeader> shipmentHeaders = new ArrayList<>();
        List<ShipmentDetail> shipmentDetails = new ArrayList<>();

        //1、找到主单，确定主单的状态是否小于100
        for (Integer id : Convert.toIntArray(ids)){
            ShipmentHeader shipmentHeader = this.getById(id);
            if(shipmentHeader == null){
                return AjaxResult.error("id为"+id+"的主单在系统不存在");
            }

            //2.小于100时，把主单和相应的子单加入到list中，大于等于100时，直接跳过
            if(shipmentHeader.getFirstStatus() < 100 && shipmentHeader.getLastStatus() <100){
                shipmentHeader.setFirstStatus(100);
                shipmentHeader.setLastStatus(100);
                shipmentHeaders.add(shipmentHeader);

                LambdaQueryWrapper<ShipmentDetail> lam = Wrappers.lambdaQuery();
                lam.eq(ShipmentDetail::getShipmentId,id)
                        .eq(ShipmentDetail::getWarehouseCode,ShiroUtils.getWarehouseCode());
                List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(lam);
                if(shipmentDetailList != null){
                    for(ShipmentDetail shipmentDetail : shipmentDetailList){
                        shipmentDetail.setStatus(100);
                    }
                    shipmentDetails.addAll(shipmentDetailList);
                }else {
                    return AjaxResult.error("id为"+id+"的出库明细在系统不存在");
                }
            }
        }

        // 3.将修改后的主单列表和子单列表进行修改，加入订单池
        Boolean flag = this.updateBatchById(shipmentHeaders);
        if (flag == false){
            throw new ServiceException("修改主单状态失败");
        }
        flag = shipmentDetailService.updateBatchById(shipmentDetails);
        if (flag == false){
            throw new ServiceException("修改明细状态失败");
        }
        return AjaxResult.success("订单审核成功,成功加入订单池");
    }

}