wms / hhwms · Files

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

import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.DataUtils;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.mobile.shipment.ShipmentBill;
import com.huaheng.pc.config.containercapacity.domain.ContainerCapacity;
import com.huaheng.pc.config.containercapacity.service.IContainerCapacityService;
import com.huaheng.pc.general.material.domain.Material;
import com.huaheng.pc.general.material.service.MaterialServiceImpl;
import com.huaheng.pc.inventory.inventory.domain.Inventory;
import com.huaheng.pc.inventory.inventory.service.IInventoryService;
import com.huaheng.pc.inventory.inventoryTransaction.domain.InventoryTransaction;
import com.huaheng.pc.inventory.inventoryTransaction.service.IInventoryTransactionService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.service.IReceiptContainerDetailService;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.service.IReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.IReceiptDetailService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.IReceiptHeaderService;
import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.IShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.IShipmentContainerHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetailSearchModel;
import com.huaheng.pc.shipment.shipmentDetail.mapper.ShipmentDetailMapper;
import com.huaheng.pc.shipment.shipmentDetail.mapper.ShipmentDetailMapperAuto;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.IShipmentHeaderService;
import com.huaheng.pc.task.task.domain.Task;
import com.huaheng.pc.task.task.service.ITaskService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.ITaskDetailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;


/**
 * 出库明细 服务层实现
 *
 * @author huaheng
 * @date 2018-08-19
 */
@Service
public class ShipmentDetailServiceImpl implements IShipmentDetailService {

    @Autowired
    private IShipmentHeaderService shipmentHeaderService;
    @Resource
    private ShipmentDetailMapperAuto aotuMapper;
    @Resource
    private ShipmentDetailMapper shipmentDetailMapper;
    @Autowired
    private MaterialServiceImpl materialService;
    @Autowired
    private IContainerCapacityService containerCapacityService;
    @Resource
    private IInventoryService iInventoryService;
    @Resource
    private IReceiptDetailService ReceiptDetailService;
    @Resource
    private IReceiptHeaderService receiptHeaderService;
    @Resource
    private IReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private IReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private IShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private IShipmentContainerDetailService shipmentContainerDetailService;
    @Resource
    private ITaskService taskService;
    @Resource
    private ITaskDetailService taskDetailService;
    @Resource
    private IInventoryTransactionService iInventoryTransactionService;






    public List<ShipmentDetail> selectListEntityByLike(ShipmentDetail condition) {
        List<ShipmentDetail> shipmentDetails = aotuMapper.selectListEntityByLike(condition);
        shipmentDetails.forEach(t->{
            Material material = new Material();
            material.setCode(t.getMaterialCode());
            material.setWarehouseCode(t.getWarehouseCode());
            material=materialService.selectFirstEntity(material);
            t.setMaterialName(material.getName());
            t.setSpecification(material.getSpecification());
            Inventory inventory=new Inventory();
            inventory.setWarehouseCode(t.getWarehouseCode());
            inventory.setMaterialCode(t.getMaterialCode());
            t.setInventoryQty(iInventoryService.getSumQty(inventory));
        });
        return shipmentDetails;
    }

    public List<ShipmentDetail> selectListEntityByEqual(ShipmentDetail condition) {
        return aotuMapper.selectListEntityByEqual(condition);
    }

    public List<ShipmentDetail> selectListDetail(ShipmentDetail condition) {
        return shipmentDetailMapper.selectListDetail(condition);
    }

    public List<ShipmentDetail> selectListAgvDetail(ShipmentDetail condition) {
        return shipmentDetailMapper.selectListAgvDetail(condition);
    }

    public AjaxResult<List<Map<String, Object>>> selectListEntity(ShipmentDetail condition,String[] ids) {
        List<Map<String, Object>> details=new ArrayList<>();
        if(ids==null || ids.length ==0){
            details = shipmentDetailMapper.selectListEntity(condition);
        }else {
            for(String id:ids){
                condition.setId(Integer.valueOf(id));
                Map<String, Object> detail = shipmentDetailMapper.selectEntity(condition);
                if(detail!=null) {
                    details.add(detail);
                }
            }
        }
        return AjaxResult.success(details);
    }

    public  AjaxResult<List<Map<String, Object>>> getAvgShipping(ShipmentDetail condition,String[] ids) {
        List<Map<String, Object>> details=new ArrayList<>();
        if(ids==null || ids.length ==0){
            details = shipmentDetailMapper.getAvgShippings(condition);
        }else {
            for(String id:ids){
                condition.setId(Integer.valueOf(id));
                Map<String, Object> detail = shipmentDetailMapper.getAvgShipping(condition);
                if(detail!=null) {
                    details.add(detail);
                }
            }
        }
        return AjaxResult.success(details);
    }

    public ShipmentDetail selectFirstEntity(ShipmentDetail condition) {
        ShipmentDetail item = aotuMapper.selectFirstEntity(condition);
        return item;
    }

    public ShipmentDetail selectEntityById(Integer id) {
        return aotuMapper.selectEntityById(id);
    }

    public List<Map<String, Object>> selectListMapByEqual(String columns, ShipmentDetail condition) {
        return aotuMapper.selectListMapByEqual(columns, condition);
    }

    public Map<String, Object> selectFirstMap(String columns, ShipmentDetail condition) {
        Map<String, Object> item = aotuMapper.selectFirstMap(columns, condition);
        return item;
    }

    public int insert(ShipmentDetail record) {
        return aotuMapper.insert(record);
    }

    public int updateByModel(ShipmentDetail record) {
        return aotuMapper.updateByModel(record);
    }

    public int updateByCondition(ShipmentDetail record, ShipmentDetail condition) {
        return aotuMapper.updateByCondition(record, condition);
    }

    public int deleteById(Integer id) {
        return aotuMapper.deleteById(id);
    }

    public int deleteByCondition(ShipmentDetail condition) {
        return aotuMapper.deleteByCondition(condition);
    }


    /**
     * 根据主单Id来获取明细并分页
     *
     * @param shipmentDetailSearchModel
     * @return
     */
    @Override
    public AjaxResult<List<ShipmentDetail>> listDetails(ShipmentDetailSearchModel shipmentDetailSearchModel) {
        ShipmentDetail condition = new ShipmentDetail();
        condition.setWarehouseId(ShiroUtils.getWarehouseId());
        List<ShipmentDetail> list = this.selectListEntityByEqual(condition);
        return AjaxResult.success(list);
    }

    /**
     * 新增出库明细
     *
     * @param shipmentDetail
     * @return
     */
    @Override
    public AjaxResult insertDetail(ShipmentDetail shipmentDetail) {
        ShipmentHeader shipmentHeader = shipmentHeaderService.selectEntityById(shipmentDetail.getShipmentId());
        if (shipmentHeader == null) {
            return AjaxResult.error("找不到主单据");
        }
        if (shipmentHeader.getFirstStatus() > 100) {
            //表示已经加入了波次
            return AjaxResult.error("主单据状态不允许新增明细");
        }
        Material material = new Material();
        material.setCode(shipmentDetail.getMaterialCode());
        material.setWarehouseId(ShiroUtils.getWarehouseId());
        material = materialService.selectFirstEntity(material);
        if (material == null) {
            return AjaxResult.error("物料未找到");
        }
        if (StringUtils.isNotEmpty(material.getCompanyCode()) &&
                ShiroUtils.getCompanyCodeList().contains(material.getCompanyCode()) == false)
        {
            return AjaxResult.error("物料不属于当前货主！");
        }
        shipmentDetail.setId(null);
        shipmentDetail.setZoneCode("LK");
        shipmentDetail.setWarehouseId(ShiroUtils.getWarehouseId());
        shipmentDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());
        shipmentDetail.setMaterialId(material.getId());
        shipmentDetail.setMaterialCode(material.getCode());
        shipmentDetail.setMaterialName(material.getName());
        shipmentDetail.setCreated(null);
        shipmentDetail.setCreatedBy(ShiroUtils.getLoginName());
        shipmentDetail.setLastUpdated(null);
        shipmentDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
        if (this.insert(shipmentDetail) > 0){
            //更新单据总行数与总数量
            shipmentHeader.setTotalLines(shipmentHeader.getTotalLines() + 1);
            shipmentHeader.setTotalQty(shipmentHeader.getTotalQty().add(shipmentDetail.getQty()));
            shipmentHeaderService.updateByModel(shipmentHeader);
            return AjaxResult.success("新增单据明细成功");
        }
        else
            return AjaxResult.error("新增单据明细失败");
    }

    /**
     * 修改出库单据明细
     *
     * @param shipmentDetail
     * @return
     */
    @Override
    public AjaxResult updateDetail(ShipmentDetail shipmentDetail) {
        ShipmentHeader shipmentHeader = shipmentHeaderService.selectEntityById(shipmentDetail.getShipmentId());
        if (shipmentHeader == null) {
            return AjaxResult.error("找不到主单据");
        }
        if (shipmentHeader.getFirstStatus() > 100) {
            return AjaxResult.error("单据状态不允许进行单据内容修改");
        }
        //ShipmentDetail entity = this.aotuMapper.selectEntityById(shipmentDetail.getId());
        shipmentDetail.setQtyCompleted(null);
        shipmentDetail.setLastUpdated(null);
        shipmentDetail.setDeleted(null);
        shipmentDetail.setCreated(null);
        shipmentDetail.setCreatedBy(ShiroUtils.getLoginName());
        shipmentDetail.setLastUpdatedBy(ShiroUtils.getLoginName());

        if (this.updateByModel(shipmentDetail) > 0) {
            //更新单据总行数与总数量
            Map<String,String> map= shipmentDetailMapper.StatisticalByReceiptId(shipmentDetail.getShipmentId());
            shipmentHeader.setTotalLines(DataUtils.getInteger(map.get("totalLines")));
            shipmentHeader.setTotalQty(DataUtils.getBigDecimal(map.get("totalQty")));
            //shipmentHeader.setTotalQty(shipmentHeader.getTotalQty().add(shipmentDetail.getQty().subtract(entity.getQty())));
            shipmentHeaderService.updateByModel(shipmentHeader);
            return AjaxResult.success("编辑单据明细成功");
        }
        else
            return AjaxResult.error("编辑单据明细失败");
    }

    /**
     * 删除出库单据明细
     *
     * @param id
     * @return
     */
    @Override
    public AjaxResult deleteDetail(String id) {
        if (StringUtils.isEmpty(id))
            return AjaxResult.error("id不能为空");
        String[] ids = id.split(",");
        List<Map<String,Integer>> list = shipmentDetailMapper.SelectFirstStatus(id);
        if (list.size() < 1) {
            return AjaxResult.error("找不到主单据！");
        }
        if (list.size() > 1) {
            return AjaxResult.error("有多个主单据，不能一起删除！");
        }
        if (list.get(0).get("firstStatus") > 100) {
            return AjaxResult.error("单据状进入订单池，不允许删除明细");
        }
        Integer result = shipmentDetailMapper.batchDelete(ids);
        if (result > 0) {
            Integer headerId=list.get(0).get("id");
            Map<String,String> map= shipmentDetailMapper.StatisticalByReceiptId(headerId);
            if(DataUtils.getInteger(map.get("totalLines")) <= 0)    {
                shipmentHeaderService.deleteById(headerId);
            }
            else    {
                //更新表头的总行数和总数量统计
                ShipmentHeader shipmentHeader = new ShipmentHeader();
                shipmentHeader.setId(headerId);
                shipmentHeader.setTotalLines(DataUtils.getInteger(map.get("totalLines")));
                shipmentHeader.setTotalQty(DataUtils.getBigDecimal(map.get("totalQty")));
                shipmentHeaderService.updateByModel(shipmentHeader);
            }
            return AjaxResult.success("删除单据明细成功");
        }
        else
            return AjaxResult.error("删除单据明细失败");
    }

    @Override
    public List<Integer> insertTodayShipmentDetail(ShipmentHeader shipmentHeader, List<ShipmentBill> shipmentBills, String companyId, String companyCode) {
        List<Integer> shipmentDetailIds = new ArrayList<>();
        if (shipmentHeader == null) {
            return null;
        }
//        if (shipmentHeader.getFirstStatus() > 100) {
//            //表示已经加入了波次
//            return null;
//        }
        for(ShipmentBill shipmentBill : shipmentBills) {
            ShipmentDetail shipmentDetail = new ShipmentDetail();
            shipmentDetail.setId(null);
            shipmentDetail.setWarehouseId(ShiroUtils.getWarehouseId());
            shipmentDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());
            shipmentDetail.setShipmentId(shipmentHeader.getId());
            shipmentDetail.setShipmentCode(shipmentHeader.getCode());
            Material condition = new Material();
            condition.setWarehouseId(ShiroUtils.getWarehouseId());
            condition.setDeleted(false);
            condition.setCode(shipmentBill.getMaterialCode());
            condition.setCompanyId(Integer.parseInt(companyId));
            condition.setCompanyCode(companyCode);
            Material material = materialService.selectFirstEntity(condition);
            shipmentDetail.setMaterialId(material.getId());
            shipmentDetail.setMaterialCode(material.getCode());
            shipmentDetail.setStatus((short) 200);
            shipmentDetail.setInventoryStatus("good");
            shipmentDetail.setQty(shipmentBill.getQty());
            shipmentDetail.setCreated(null);
            shipmentDetail.setCreatedBy(ShiroUtils.getLoginName());
            shipmentDetail.setCompanyId(Integer.parseInt(companyId));
            shipmentDetail.setCompanyCode(companyCode);
            shipmentDetail.setLastUpdated(null);
            shipmentDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
            if (this.insert(shipmentDetail) > 0) {
                shipmentHeaderService.statistics(shipmentDetail.getShipmentId());
            }
            shipmentDetailIds.add(shipmentDetail.getId());
        }
        return shipmentDetailIds;
    }

    @Override
    public Integer countUnCompleted(Integer shipmentId) {
        return shipmentDetailMapper.countUnCompleted(shipmentId);
    }

    @Override
    public List<ShipmentDetail> getShipmentDetailListByLike(ShipmentDetail shipmentDetail) {
        return shipmentDetailMapper.getShipmentDetailListByLike(shipmentDetail);
    }

    @Override
    public AjaxResult check(ShipmentDetail shipmentDetail) {
        ShipmentDetail record=this.selectEntityById(shipmentDetail.getId());
        ContainerCapacity containerCapacity=new ContainerCapacity();
        containerCapacity.setMaterialCode(record.getMaterialCode());
        containerCapacity=containerCapacityService.selectFirstEntity(containerCapacity);
        if(containerCapacity==null){
            throw new ServiceException("id为"+shipmentDetail.getId()+"细单的物料没有在AGV库区的满盘度，请先设置该物料的满盘度.");
        }
        return AjaxResult.success("");
    }

    @Override
    public void updateMatarial(ShipmentDetail shipmentDetail) {
        Material material=new Material();
        material.setCode(shipmentDetail.getMaterialCode());
        material.setWarehouseCode(shipmentDetail.getWarehouseCode());
        material=materialService.selectFirstEntity(material);
        if(material==null){
            throw new ServiceException("id为"+shipmentDetail.getId()+"的物料在系统中不存在");
        }
        if(StringUtils.isEmpty(material.getZoneCode())){
            material.setZoneCode(shipmentDetail.getZoneCode());
            int result=materialService.updateByModel(material);
            if(result<1){
                throw new ServiceException("分配库区失败");
            }
        }
    }

    @Override
    public List<Map<String, Object>> selectList(String code, String goodsShelfNo) {
        String warehouseCode=ShiroUtils.getWarehouseCode();
        String shelfNo=goodsShelfNo.substring(1,5);
        return shipmentDetailMapper.selectLists(code,shelfNo,warehouseCode);
    }

    @Override
    public int updateDetails(String code) {
        return shipmentDetailMapper.updateDetails(code);
    }
    /**
     * 越库
     *
     * 以出库单为基准，只要剩余物料存在可以组盘的，先比对库存，有库存就提示，没有库存 就对比未组盘完成的入库单
     * 有对应则修改已入已出数量，再自动完成全部流程。
     * status200入库组盘完成未下发
     *
     * */
    @Transactional
    @Override
    public AjaxResult rossDoccking(Integer id) {

        ShipmentDetail shipmentDetail = this.selectEntityById(id);//查询选中的出库单明细,
        //当前出库单中剩余的物料数量
        BigDecimal tempQty = shipmentDetail.getQty().subtract(shipmentDetail.getQtyCompleted());
        int i = tempQty.compareTo(BigDecimal.ZERO);
        if(i <= 0){
            return AjaxResult.success("该单据物料已出库完毕！");
        }
        //对比库存
        Inventory inventory =new Inventory();
        inventory.setWarehouseId(ShiroUtils.getWarehouseId());
        inventory.setMaterialCode(shipmentDetail.getMaterialCode());
        inventory.setStatus(shipmentDetail.getInventoryStatus());
        inventory.setTaskQty(BigDecimal.ZERO);
        inventory.setDeleted(false);
        List<Inventory> invList = iInventoryService.selectListEntityByEqual(inventory);
        if(invList.size() != 0){
            return AjaxResult.success("库存中存在该物料，请优先出库已有库存！");
        }
        //对比入库单,查询status 小于 收货200 订单池100
        ReceiptDetail receiptDetail = new ReceiptDetail();
        receiptDetail.setDeleted(false);
        receiptDetail.setInventoryStatus(shipmentDetail.getInventoryStatus());
        receiptDetail.setWarehouseId(ShiroUtils.getWarehouseId());
        receiptDetail.setMaterialCode(shipmentDetail.getMaterialCode());
        receiptDetail.setQtyCompleted(BigDecimal.ZERO);//入库只能整盘入库，所以找的时候只从初始状态的单据找
        //入库只有整盘，所以不考虑没有入完的单据，但是需要找和出库单物料数量最相近的。可以大于或者小于出库单物料数量。7天内的单据

        ReceiptDetail receiptDetailD = ReceiptDetailService.rossDoccking(receiptDetail,id);//找差值最小
        if(receiptDetailD == null){
            return AjaxResult.success("入库单中没有可以越库的物料！");
        }
        Material material1 = materialService.getEnableMaterialByCode(receiptDetailD.getMaterialCode());//物料
        receiptDetailD.setMaterialName(material1.getName());
        shipmentDetail.setMaterialName(receiptDetailD.getMaterialName());//出库物料名称
        //找到入库单明细里有对应的物料，修改相应的数量，按照流程写入到相应的表中

        /************/
        receiptDetailD.setQtyCompleted(tempQty);
        //物料全部入完是800，没有是200
        int j = receiptDetailD.getQtyCompleted().compareTo(receiptDetailD.getQty());
        //总出库数量是之前出的数量加这一次出的数量
        BigDecimal shipmentQty = tempQty.add(shipmentDetail.getQtyCompleted());
        BigDecimal tempBd = BigDecimal.ONE;//实际出库数量。
        //shipmentDetail.setQtyCompleted(shipmentQty);
        if(j > 0 ){
            receiptDetailD.setQtyCompleted(receiptDetailD.getQty());
            receiptDetailD.setStatus((short)200);
            //获取到入库单据的数量然后加入到出库单的已出数量,如果对应的入库单数量少于出库单数量以入库单数量为准
            BigDecimal shipmentQty2 = receiptDetailD.getQtyCompleted().add(shipmentDetail.getQtyCompleted());//总出库数量是之前出的数量加这一次出的数量
            tempBd = receiptDetailD.getQtyCompleted();
            shipmentDetail.setQtyCompleted(shipmentQty2);
        }else if(j == 0){
            tempBd = tempQty;
            shipmentDetail.setQtyCompleted(shipmentQty);
            receiptDetailD.setStatus((short)200);
        }else if(j < 0 ){
            tempBd = tempQty;
            shipmentDetail.setQtyCompleted(shipmentQty);
            receiptDetailD.setStatus((short)100);
        }
        //修改入库单明细表
        int c = ReceiptDetailService.updateByModel(receiptDetailD);
        if(c < 0 ){
            throw new ServiceException("修改入库明细单据错误！");
        }

        //根据明细表修改主表状态
        ReceiptDetail rec = new ReceiptDetail();
        rec.setWarehouseId(ShiroUtils.getWarehouseId());
        rec.setReceiptCode(receiptDetailD.getReceiptCode());
        rec.setReceiptId(receiptDetailD.getReceiptId());
        List<ReceiptDetail> ListLong = ReceiptDetailService.selectListEntityByEqual(rec);
        ReceiptHeader receiptHeader = receiptHeaderService.selectEntityById(receiptDetailD.getReceiptId());
        //如果当前单据只有一条子单则状态和子单一样，否则不一样
        long count = ListLong.stream().filter(t->t.getStatus() >= 200).count();
        if(count != ListLong.size()){
            //明细单的完成状态数目小于明细单的条数，说明还有未收货明细
            receiptHeader.setFirstStatus(receiptDetailD.getStatus());
        }else {
            //明细单的完成状态数目等于明细单的条数，说明全部明细收货完成
            receiptHeader.setFirstStatus(receiptDetailD.getStatus());
            receiptHeader.setLastStatus(receiptDetailD.getStatus());
        }
        int t = receiptHeaderService.updateByModel(receiptHeader);
        if(t < 0){
            throw new ServiceException("修改入库主单据状态错误！");
        }
        //写入入库组盘及组盘明细，使用虚拟库位及虚拟容器

        ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
        receiptContainerHeader.setReceiptContainerCode("XN00001");//使用虚拟容器
        receiptContainerHeader.setLocationCode("XN00-00-00-01");//虚拟库位
        receiptContainerHeader.setStatus((short)20);
        receiptContainerHeader.setTaskType((short)100);
        receiptContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
        receiptContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        receiptContainerHeader.setCompanyId(receiptDetailD.getCompanyId());
        receiptContainerHeader.setCompanyCode(receiptDetailD.getCompanyCode());
        receiptContainerHeader.setCompanyId(receiptDetailD.getCompanyId());
        receiptContainerHeader.setCompanyCode(receiptDetailD.getCompanyCode());
        receiptContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
        int q = receiptContainerHeaderService.insert(receiptContainerHeader);
        if(q < 1){
            throw new ServiceException("增加入库组盘主单失败！");
        }

        //组盘明细
        ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
        receiptContainerDetail.setHeaderId(receiptContainerHeader.getId());//上面生成的组盘主单
        receiptContainerDetail.setReceiptDetailId(receiptDetailD.getId());
        receiptContainerDetail.setReceiptCode(receiptDetailD.getReceiptCode());
        receiptContainerDetail.setReceiptId(receiptDetailD.getReceiptId());
        receiptContainerDetail.setMaterialCode(receiptDetailD.getMaterialCode());
        receiptContainerDetail.setMaterialName(material1.getName());
        receiptContainerDetail.setMaterialSpec(material1.getSpecification());
        receiptContainerDetail.setQty(receiptDetailD.getQtyCompleted());
        receiptContainerDetail.setCreatedBy(ShiroUtils.getLoginName());

        int w = receiptContainerDetailService.insert(receiptContainerDetail);
        if(w < 1){
            throw new ServiceException("增加入库组盘明细单失败！");
        }
        //入库task任务表及明细表
        Task task = new Task();
        task.setBeginTime(new Date());
        task.setWarehouseId(ShiroUtils.getWarehouseId());
        task.setWarehouseCode(ShiroUtils.getWarehouseCode());
        task.setCompanyId(receiptContainerHeader.getCompanyId());
        task.setCompanyCode(receiptContainerHeader.getCompanyCode());
        task.setPriority(99);
        task.setType(receiptContainerHeader.getTaskType());
        task.setAllocationHeadId(receiptContainerHeader.getId());
        task.setRoadway(0);//虚拟巷道
        task.setStation(9999);//虚拟站台
        task.setDestinationLocation(receiptContainerHeader.getLocationCode());
        task.setContainerCode(receiptContainerHeader.getReceiptContainerCode());
        task.setFirstStatus((short) 40);
        task.setLastStatus((short) 40);
        task.setCreated(new Date());
        task.setCreatedBy(ShiroUtils.getLoginName());
        task.setEndTime(new Date());//任务完成时间
        task.setLastUpdatedBy(ShiroUtils.getLoginName());
        int m =taskService.insert(task);
        if(m < 1){
            throw new ServiceException("增加入库Task失败！");
        }
        //task明细
        TaskDetail taskDetail = new TaskDetail();
        taskDetail.setTaskId(task.getId());
        taskDetail.setWarehouseId(task.getWarehouseId());
        taskDetail.setWarehouseCode(task.getWarehouseCode());
        taskDetail.setCompanyId(task.getCompanyId());
        taskDetail.setCompanyCode(task.getCompanyCode());
        taskDetail.setMaterialCode(receiptContainerDetail.getMaterialCode());
        taskDetail.setMaterialName(receiptContainerDetail.getMaterialName());
        taskDetail.setAllocationId(receiptContainerDetail.getId());
        taskDetail.setBillId(receiptContainerDetail.getReceiptId());
        taskDetail.setBillDetailId(receiptContainerDetail.getReceiptDetailId());
        taskDetail.setBillCode(receiptContainerDetail.getReceiptCode());
        taskDetail.setQty(receiptContainerDetail.getQty());
        taskDetail.setContainerCode(task.getContainerCode());
        taskDetail.setDestinationLocation(task.getDestinationLocation());
        taskDetail.setEndTime(new Date());
        taskDetail.setSourceLocation(task.getSourceLocation());
        taskDetail.setStatus(task.getLastStatus());
        taskDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
        int n =  taskDetailService.insert(taskDetail);
        if(n <1 ){
            throw new ServiceException("增加入库Task明细失败！");
        }

        //写入库存表及库存交易表
        Inventory inventory1 = new Inventory();
        inventory1.setWarehouseId(ShiroUtils.getWarehouseId());
        inventory1.setWarehouseCode(ShiroUtils.getWarehouseCode());
        inventory1.setLocationCode(receiptContainerHeader.getLocationCode());
        inventory1.setContainerCode(receiptContainerHeader.getReceiptContainerCode());
        inventory1.setSourceCode(receiptDetailD.getSourceCode());
        inventory1.setSourceLine(receiptDetailD.getSourceLine());
        inventory1.setCompanyId(receiptDetailD.getCompanyId());
        inventory1.setCompanyCode(receiptDetailD.getCompanyCode());
        inventory1.setMaterialCode(receiptContainerDetail.getMaterialCode());
        inventory1.setMaterialName(receiptContainerDetail.getMaterialName());
        inventory1.setReceiptCode(receiptContainerDetail.getReceiptCode());
        inventory1.setReceiptId(receiptContainerDetail.getReceiptId());
        inventory1.setReceiptDetailId(receiptContainerDetail.getReceiptDetailId());
        inventory1.setBatch(receiptDetailD.getBatch());
        inventory1.setLot(receiptDetailD.getLot());
        inventory1.setProject(receiptDetailD.getProject());
        inventory1.setManufactureDate(receiptDetailD.getManufactureDate());
        inventory1.setExpirationDate(receiptDetailD.getExpirationDate());
        inventory1.setStatus(receiptDetailD.getInventoryStatus());
        inventory1.setQty(receiptContainerDetail.getQty());
        inventory1.setTaskQty(BigDecimal.ZERO);
        inventory1.setCostPrice(BigDecimal.ZERO);
        inventory1.setListPrice(BigDecimal.ZERO);
        inventory1.setNetPrice(BigDecimal.ZERO);
        inventory1.setCreatedBy(ShiroUtils.getLoginName());
        inventory1.setLastUpdatedBy(ShiroUtils.getLoginName());
        int k = iInventoryService.insert(inventory1);
        if(k <1  ){
            throw new ServiceException("入库单写入库存失败");
        }
        //库存交易
        InventoryTransaction inventoryTransaction = new InventoryTransaction();
        inventoryTransaction.setType("receipt");
        inventoryTransaction.setWarehouseId(inventory1.getWarehouseId());
        inventoryTransaction.setWarehouseCode(inventory1.getWarehouseCode());
        inventoryTransaction.setCompanyId(inventory1.getCompanyId());
        inventoryTransaction.setCompanyCode(inventory1.getCompanyCode());
        inventoryTransaction.setLocationCode(inventory1.getLocationCode());
        inventoryTransaction.setContainerCode(inventory1.getContainerCode());
        inventoryTransaction.setSourceCode(inventory1.getSourceCode());
        inventoryTransaction.setSourceLine(inventory1.getSourceLine());
        inventoryTransaction.setMaterialCode(inventory1.getMaterialCode());
        inventoryTransaction.setMaterialName(inventory1.getMaterialName());
        inventoryTransaction.setBillCode(inventory1.getReceiptCode());
        inventoryTransaction.setBillId(inventory1.getReceiptId());
        inventoryTransaction.setBillDetailId(inventory1.getReceiptDetailId());
        inventoryTransaction.setBatch(inventory1.getBatch());
        inventoryTransaction.setLot(inventory1.getLot());
        inventoryTransaction.setProject(inventory1.getProject());
        inventoryTransaction.setManufactureDate(inventory1.getManufactureDate());
        inventoryTransaction.setExpirationDate(inventory1.getExpirationDate());
        inventoryTransaction.setStatus(inventory1.getStatus());
        inventoryTransaction.setQty(BigDecimal.ZERO);
        inventoryTransaction.setTaskQty(inventory1.getQty());
        inventoryTransaction.setCostPrice(BigDecimal.ZERO);
        inventoryTransaction.setCreated(new Date());
        inventoryTransaction.setCreatedBy(ShiroUtils.getLoginName());
        inventoryTransaction.setLastUpdated(new Date());
        inventoryTransaction.setLastUpdatedBy(ShiroUtils.getLoginName());
        int p = iInventoryTransactionService.insert(inventoryTransaction);
        if(p <1){
            throw new ServiceException("入库库存交易写入失败！");
        }

        //出库
        //出库明细单修改状态和已出数量
        //获取到入库单据的数量然后加入到出库单的已出数量,如果对用的入库单数量少于出库单数量
        //对应入库单的以出数量必须是0，那么就是出库单的数量决定总的出库数量

        //物料全部出完是300，没有是200
        int s = shipmentDetail.getQtyCompleted().compareTo(shipmentDetail.getQty());
        if(s == 0){//已出数量等于单据数量
            shipmentDetail.setStatus((short)300);
        }else if(s < 0 ){//已出数量小于单据
            shipmentDetail.setStatus((short)200);
        }else{
            throw new ServiceException("出库数量不能大于出库单据数量！");
        }
        int l = this.updateByModel(shipmentDetail);
        if(l <1){
            throw new ServiceException("修改出库明细状态失败！");
        }
        //根据明细，修改主表状态
        ShipmentDetail sd = new ShipmentDetail();
        sd.setWarehouseId(shipmentDetail.getWarehouseId());
        sd.setShipmentCode(shipmentDetail.getShipmentCode());
        sd.setShipmentId(shipmentDetail.getShipmentId());
        List<ShipmentDetail> Listsd = this.selectListEntityByEqual(sd);
        ShipmentHeader shipmentHeader = shipmentHeaderService.selectEntityById(sd.getShipmentId());
        //如果当前单据只有一条子单则状态和子单一样，否则不一样
        long count2 = Listsd.stream().filter(t2->t2.getStatus() >= 300).count();
        if(count2 != Listsd.size()){
            //明细单的完成状态数目小于明细单的条数，说明还有未收货明细
            shipmentHeader.setFirstStatus(200);
        }else {
            //明细单的完成状态数目等于明细单的条数，说明全部明细收货完成
            shipmentHeader.setFirstStatus(300);
            shipmentHeader.setLastStatus(300);
        }
        int y = shipmentHeaderService.updateByModel(shipmentHeader);
        if( y <1){
            throw new ServiceException("修改出库主单据状态错误！");
        }

        //出库组盘及明细
        ShipmentContainerHeader shipmentContainerHeader = new ShipmentContainerHeader();
        shipmentContainerHeader.setTaskType((short)300);
        shipmentContainerHeader.setTaskTypeReal((short)300);//预期任务类型
        shipmentContainerHeader.setShipmentContainerCode("XN00001");//虚拟容器
        shipmentContainerHeader.setLocationCode("XN00-00-00-01");//虚拟库位
        shipmentContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        shipmentContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
        shipmentContainerHeader.setCompanyId(shipmentDetail.getCompanyId());
        shipmentContainerHeader.setCompanyCode(shipmentDetail.getCompanyCode());
        shipmentContainerHeader.setStatus((short)20);
        shipmentContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
        //shipmentContainerHeader.setCreated(null);
        int h = shipmentContainerHeaderService.insert(shipmentContainerHeader);
        if(h <1){
            throw new ServiceException("新增出库组盘头失败！");
        }
        //组盘明细

        ShipmentContainerDetail shipmentContainerDetail = new ShipmentContainerDetail();
        shipmentContainerDetail.setHeaderId(shipmentContainerHeader.getId());
        shipmentContainerDetail.setShipmentCode(shipmentDetail.getShipmentCode());
        shipmentContainerDetail.setShipmentHeaderId(shipmentDetail.getShipmentId());
        shipmentContainerDetail.setShipmentDetailId(shipmentDetail.getId());
        shipmentContainerDetail.setMaterialCode(shipmentDetail.getMaterialCode());
        shipmentContainerDetail.setMaterialName(shipmentDetail.getMaterialName());
        //出库单的库存ID必须对应选中的入库单
        Inventory checkIn = iInventoryService.selectEntityById(inventory1.getId());
        if(!checkIn.getReceiptDetailId().equals(receiptDetailD.getId())){
            throw new ServiceException("出库库存不是选中入库单的对应库存！");
        }
        shipmentContainerDetail.setInventoryId(inventory1.getId());
        //shipmentContainerDetail.setCreated(null);
        shipmentContainerDetail.setQty(tempBd);
        shipmentContainerDetail.setCreatedBy(ShiroUtils.getLoginName());
        int r = shipmentContainerDetailService.insert(shipmentContainerDetail);
        if(r <1 ){
            throw new ServiceException("增加出库组盘明细失败！");
        }
        //出库task任务表，及任务明细表

        Task task1 = new Task();
        task1.setType((short)300);
        task1.setRoadway(0);//出库巷道
        task1.setBeginTime(new Date());
        task1.setWarehouseId(shipmentContainerHeader.getWarehouseId());
        task1.setWarehouseCode(shipmentContainerHeader.getWarehouseCode());
        task1.setCompanyId(shipmentContainerHeader.getCompanyId());
        task1.setCompanyCode(shipmentContainerHeader.getCompanyCode());
        task1.setPriority(99);
        task1.setAllocationHeadId(shipmentContainerHeader.getId());
        task1.setStation(9999);
        task1.setContainerCode(shipmentContainerHeader.getShipmentContainerCode());
        task1.setSourceLocation(shipmentContainerHeader.getLocationCode());
        task1.setFirstStatus((short)40);
        task1.setLastStatus((short)40);
        task1.setCreatedBy(ShiroUtils.getLoginName());
        task1.setCreated(new Date());
        task1.setEndTime(new Date());//任务完成时间
        task1.setLastUpdatedBy(ShiroUtils.getLoginName());
        task1.setLastUpdatedBy(ShiroUtils.getLoginName());
        int b = taskService.insert(task1);
        if(b <1){
            throw new ServiceException("增加出库task表失败！");
        }

        //出库task明细
        TaskDetail taskDetail1 = new TaskDetail();
        taskDetail1.setTaskId(task1.getId());
        taskDetail1.setWarehouseCode(task1.getWarehouseCode());
        taskDetail1.setWarehouseId(task1.getWarehouseId());
        taskDetail1.setCompanyId(task1.getCompanyId());
        taskDetail1.setCompanyCode(task1.getCompanyCode());
        taskDetail1.setAllocationId(shipmentContainerDetail.getId());
        taskDetail1.setBillCode(shipmentContainerDetail.getShipmentCode());
        taskDetail1.setBillId(shipmentContainerDetail.getShipmentHeaderId());
        taskDetail1.setBillDetailId(shipmentContainerDetail.getShipmentDetailId());
        taskDetail1.setMaterialCode(shipmentContainerDetail.getMaterialCode());
        taskDetail1.setMaterialName(shipmentContainerDetail.getMaterialName());
        taskDetail1.setInventoryId(shipmentContainerDetail.getInventoryId());
        taskDetail1.setQty(shipmentContainerDetail.getQty());
        taskDetail1.setContainerCode(task1.getContainerCode());
        taskDetail1.setSourceLocation(task1.getSourceLocation());
        taskDetail1.setDestinationLocation(task1.getDestinationLocation());
        taskDetail1.setStatus(task1.getLastStatus());
        taskDetail1.setEndTime(new Date());
        taskDetail1.setLastUpdatedBy(ShiroUtils.getLoginName());
        taskDetail1.setLastUpdated(new Date());
        int v = taskDetailService.insert(taskDetail1);
        if(v <1){
            throw new ServiceException("增加出库task明细表失败！");
        }
        //删除库存和写入库存交易
        Inventory inventory2 = new Inventory();
        inventory2.setId(checkIn.getId());
        inventory2.setReceiptDetailId(receiptDetailD.getId());
        inventory2.setWarehouseId(ShiroUtils.getWarehouseId());
        inventory2.setWarehouseCode(shipmentDetail.getWarehouseCode());
        inventory2.setMaterialCode(shipmentContainerDetail.getMaterialCode());
        //inventory2.setQty(tempQty);
        inventory2.setLocationCode("XN00-00-00-01");
        inventory2.setContainerCode("XN00001");
        int f = iInventoryService.deleteByCondition(inventory2);
        if(f <1){
            throw new ServiceException("删除库存失败！");
        }

        //出库存交易
        InventoryTransaction inventoryTransaction1 = new InventoryTransaction();
        inventoryTransaction1.setWarehouseId(task1.getWarehouseId());
        inventoryTransaction1.setWarehouseCode(task1.getWarehouseCode());
        inventoryTransaction1.setCompanyId(taskDetail1.getCompanyId());
        inventoryTransaction1.setCompanyCode(taskDetail1.getCompanyCode());
        inventoryTransaction1.setLocationId(checkIn.getLocationId());
        inventoryTransaction1.setLocationCode(checkIn.getLocationCode());
        inventoryTransaction1.setContainerCode(checkIn.getContainerCode());
        inventoryTransaction1.setSourceCode(shipmentDetail.getSourceCode());
        inventoryTransaction1.setSourceLine(shipmentDetail.getSourceLine());
        inventoryTransaction1.setType("shipment");
        inventoryTransaction1.setMaterialCode(taskDetail1.getMaterialCode());
        inventoryTransaction1.setMaterialName(taskDetail1.getMaterialName());//物料名称
        inventoryTransaction1.setBillId(taskDetail1.getBillId());
        inventoryTransaction1.setBillCode(taskDetail1.getBillCode());
        inventoryTransaction1.setBillDetailId(shipmentDetail.getId());
        inventoryTransaction1.setBatch(shipmentDetail.getBatch());
        inventoryTransaction1.setLot(shipmentDetail.getLot());
        inventoryTransaction1.setManufactureDate(shipmentDetail.getManufactureDate());
        inventoryTransaction1.setExpirationDate(shipmentDetail.getExpirationDate());
        inventoryTransaction1.setStatus(checkIn.getStatus());
        inventoryTransaction1.setQty(checkIn.getQty());
        inventoryTransaction1.setTaskQty(taskDetail1.getQty().negate());
        inventoryTransaction1.setCreated(new Date());
        inventoryTransaction1.setCreatedBy(ShiroUtils.getLoginName());
        inventoryTransaction1.setLastUpdated(new Date());
        inventoryTransaction1.setLastUpdatedBy(ShiroUtils.getLoginName());
        int z = iInventoryTransactionService.insert(inventoryTransaction1);
        if(z <1){
            throw new ServiceException("生成出库库存交易失败！");
        }

        return AjaxResult.success("200","出库明细单ID"+ shipmentDetail.getId() +"的物料"+shipmentDetail.getMaterialCode()+"物料名称“"+shipmentDetail.getMaterialName()+"”越库至入库单ID为"+receiptDetailD.getReceiptCode()+"的明细单ID"+receiptDetailD.getId()+"成功,请注意分拣！!");

    }

    @Override
    public List<ShipmentDetail> getShipmentQtyLast7Days() {
        return shipmentDetailMapper.getShipmentQtyLast7Days();
    }

    @Override
    public List<ShipmentDetail> getWarehouseShipment() {
        return shipmentDetailMapper.getWarehouseShipment();
    }

    @Override
    public List<ShipmentDetail> getCompanyShipment() {
        return shipmentDetailMapper.getCompanyShipment();
    }
}