ReceiptContainerHeaderServiceImpl.java 37.2 KB

Edit Raw Blame History

package com.huaheng.pc.receipt.receiptContainerHeader.service;

import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.mobile.receipt.ReceiptBill;
import com.huaheng.pc.config.zone.domain.Zone;
import com.huaheng.pc.config.zone.service.IZoneService;
import com.huaheng.pc.general.container.domain.Container;
import com.huaheng.pc.config.containercapacity.domain.ContainerCapacity;
import com.huaheng.pc.general.container.service.IContainerService;
import com.huaheng.pc.general.location.domain.Location;
import com.huaheng.pc.general.location.service.ILocationService;
import com.huaheng.pc.general.material.domain.Material;
import com.huaheng.pc.general.material.service.IMaterialService;
import com.huaheng.pc.inventory.inventory.domain.Inventory;
import com.huaheng.pc.inventory.inventory.service.IInventoryService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.mapper.ReceiptContainerDetailMapper;
import com.huaheng.pc.receipt.receiptContainerDetail.service.IReceiptContainerDetailService;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerView;
import com.huaheng.pc.receipt.receiptContainerHeader.mapper.ReceiptContainerHeaderMapper;
import com.huaheng.pc.receipt.receiptContainerHeader.mapper.ReceiptContainerHeaderMapperAuto;
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.task.task.service.ITaskService;
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.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 入库组盘头 服务层实现
 *
 * @author huaheng
 * @date 2018-08-19
 */
@Service
public class ReceiptContainerHeaderServiceImpl implements IReceiptContainerHeaderService {

    @Autowired
    IMaterialService materialService;
    @Autowired
    IContainerService containerService;
    @Autowired
    ILocationService locationService;
    @Autowired
    ITaskService taskService;
    @Autowired
    IReceiptHeaderService receiptHeaderService;
    @Autowired
    IReceiptDetailService receiptDetailService;
    @Autowired
    IReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ReceiptContainerDetailMapper receiptContainerDetailMapper;
    @Resource
    ReceiptContainerHeaderMapper receiptContainerHeaderMapper;
    @Resource
    private ReceiptContainerHeaderMapperAuto aotuMapper;
    @Autowired
    private IZoneService zoneService;
    @Resource
    private IInventoryService inventoryService;

    public List<ReceiptContainerHeader> selectListEntityByLike(ReceiptContainerHeader condition) {
        return aotuMapper.selectListEntityByLike(condition);
    }

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

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

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

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

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

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

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

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

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

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

    @Override
    public List<ReceiptContainerHeader> selectListByLike(ReceiptContainerHeader condition) {
        return receiptContainerHeaderMapper.selectListByLike(condition);
    }

    @Override
    public AjaxResult deleteHeader(Integer[] ids) {
        for (Integer id : ids) {
            ReceiptContainerHeader receiptContainerHeader = this.selectEntityById(id);
            if (receiptContainerHeader == null)   {
                return AjaxResult.error("没有找到组盘！");
            }
            if (receiptContainerHeader.getStatus() > 9)                {
                return AjaxResult.error("配盘单生成任务，不能删除！");
            }
            ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
            receiptContainerDetail.setHeaderId(id);
            List<ReceiptContainerDetail> list = receiptContainerDetailService.selectListEntityByEqual(receiptContainerDetail);
            for (ReceiptContainerDetail item : list) {
                //扣除已收货数量
                receiptContainerDetailMapper.updateReceiptDetailQty(item.getReceiptDetailId(), item.getQty());
                //将已收货数量为0的入库单据明细状态改为0
                receiptContainerDetailMapper.updateReceiptDetailStatus(item.getReceiptDetailId());
                //删除配盘明细
                receiptContainerDetailService.deleteById(item.getId());
            }
            //删除配盘主表
            this.deleteById(id);
            //解除库位锁定
            if (StringUtils.isNotEmpty(receiptContainerHeader.getLocationCode()))   {
                locationService.updateStatus(receiptContainerHeader.getLocationCode(), "empty");
            }
            //判断该单据是否还有其他组盘，没有则将该单据更新到新建状态
            list.stream().map(X -> X.getReceiptId()).distinct().forEach(X -> {
                Integer count = receiptContainerDetailService.countByReceiptId(X);
                if(count==0) {
                    //恢复单据主表到新建状态
                    ReceiptHeader receiptHeader = new ReceiptHeader();
                    receiptHeader.setId(id);
                    receiptHeader.setFirstStatus((short) 0);
                    receiptHeader.setLastStatus((short) 0);
                    receiptHeaderService.updateByModel(receiptHeader);
                }
            });
        }
        return AjaxResult.success("配盘单删除成功！");
    }

    @Override
    public AjaxResult checkContainer(ReceiptContainerView record) {
        if (StringUtils.isEmpty(record.getReceiptContainerCode()))
            throw new ServiceException("容器不能为空");
        Container container = new Container();
        container.setCode(record.getReceiptContainerCode());
        container.setWarehouseId(ShiroUtils.getWarehouseId());
        container = containerService.selectFirstEntity(container);
        if (container == null)
            throw new ServiceException("容器没有在系统注册！");
        if (container.getWarehouseId() != ShiroUtils.getWarehouseId())
            throw new ServiceException("容器不在当前仓库！");
        if(record.getZoneCode().equals("AGV")){
            record.setTaskType((short)200);
        }
        if(record.getTaskType().intValue() == 100){
            if (StringUtils.isNotEmpty(container.getLocationCode())) {
                throw new ServiceException("容器已经在货架" + container.getLocationCode() + "上！");
            }
        }
        if(record.getTaskType().intValue() == 200) {
            if (StringUtils.isEmpty(container.getLocationCode())) {
                throw new ServiceException("容器不在货架" + container.getLocationCode() + "上！");
            }
        }
        //库区
        //容器和物料库位类型进行匹配
        Zone zone = new Zone();
        zone.setWarehouseId(ShiroUtils.getWarehouseId());
        zone.setCode(record.getZoneCode());
        zone.setDeleted(false);
        Zone zo = zoneService.selectFirstEntity(zone);
        //地面库区可以放任意物料，不校验

        if(StringUtils.isNotEmpty(record.getZoneCode())){
        if(container.getType().equals("D")){
            return AjaxResult.success("");
        }else if(container.getType().equals("M") && zo.getLocationType().equals("LK")){
            return AjaxResult.success("");
        }else if(container.getType().equals("L") && zo.getLocationType().equals("LK")){
            return AjaxResult.success("");
        }else if(container.getType().equals("A") && zo.getLocationType().equals("AGV")){
            return AjaxResult.success("");
        }else if(container.getType().equals("Q") && zo.getLocationType().equals("QG")){
            return AjaxResult.success("");
        }else{
            throw new ServiceException("物料不适用与该容器托盘！请更换容器托盘");
        }
       }
        return AjaxResult.success("");
    }

//    @Override
//    public Boolean checkLocationCode(ReceiptContainerView record) {
//        boolean result = innerCheckLocationCode(record);
//        Location location = new Location();
//        location.setWarehouseId(ShiroUtils.getWarehouseId());
//        location.setDeleted(false);
//        location.setCode(record.getLocationCode());
//        location = locationService.selectFirstEntity(location);
//        location.setStatus("lock");
//        return  result;
//    }

    @Override
    public Boolean mobileCheckLocationCode(ReceiptContainerView record) {
        //如果选了库位，就要校验库位和已经组盘的库位是否一致，避免重入库
        return checkLocationCode(record);
    }

    private Boolean checkLocationCode(ReceiptContainerView record) {
        //如果选了库位，就要校验库位和已经组盘的库位是否一致，避免重入库
        if(!record.getZoneCode().equals("AGV")) {
            if (StringUtils.isEmpty(record.getLocationCode())) {
                if (record.getTaskType().intValue() == 200)
                    throw new ServiceException("补充入库，必须填写库位");
                else
                    return true;
            }
        }
        Location location = new Location();
        if(record.getZoneCode().equals("AGV")){
            location.setContainerCode(record.getReceiptContainerCode());
            location.setWarehouseCode(ShiroUtils.getWarehouseCode());
            location.setDeleted(false);
            location = locationService.selectFirstEntity(location);
            record.setLocationCode(location.getCode());
        }else {
            location.setCode(record.getLocationCode());
            location.setWarehouseCode(ShiroUtils.getWarehouseCode());
            location.setDeleted(false);
            location = locationService.selectFirstEntity(location);
        }
        ReceiptContainerHeader condition = new ReceiptContainerHeader();
        condition.setWarehouseCode(ShiroUtils.getWarehouseCode());
        condition.setReceiptContainerCode(record.getReceiptContainerCode());
//        condition.setTaskType(record.getTaskType());
        condition.setStatus((short)0);
        ReceiptContainerHeader receiptContainerHeader = this.selectFirstEntity(condition);
        if (receiptContainerHeader != null) {
            if (receiptContainerHeader.getLocationCode().equals(record.getLocationCode()))
                return true;
            else
                throw new ServiceException("容器(" + record.getReceiptContainerCode() + ")对应的库位是：" + receiptContainerHeader.getLocationCode());
        }
        if (location == null)
            throw new ServiceException("库位不存在！");
        if (location.getEnable() == false)
            throw new ServiceException("库位被禁用！");
        if (location.getStatus().equals("empty") == false)
            throw new ServiceException("库位不是空闲状态！");
        //AGV库区的只能补充入库
        //钱柜库区的只能补充入库
        if (location.getZoneCode().equals("QG"))  {
            record.setTaskType((short)200);
        }

        if (record.getTaskType().intValue() == 100) {
            if (StringUtils.isNotEmpty(location.getContainerCode()))
                throw new ServiceException("库位(" + record.getLocationCode() + ")有容器(" + location.getContainerCode() + ")，不能整盘入库！");
        }
        if(record.getTaskType().intValue() == 200)  {
            if (StringUtils.isEmpty(location.getContainerCode()))
                throw new ServiceException("库位(" + record.getLocationCode() + ")没有容器，不能补充入库！");
            else  if (location.getContainerCode().equals(record.getReceiptContainerCode()) == false)
                throw new ServiceException("库位(" + record.getLocationCode() + ")对应的容器是：" + location.getContainerCode()+ "，请重选库位！");
        }
//        location.setWarehouseId(ShiroUtils.getWarehouseId());
//        location.setCode(record.getLocationCode());
//        location.setEnable(true);
//        location.setDeleted(false);
//        Location lo1 = locationService.selectFirstEntity(location);
//        //地面库位不做物料校验
//        if(!lo1.getType().equals("DM") && StringUtils.isNotEmpty(record.getZoneCode())){
//            if(!lo1.getZoneCode().equals(record.getZoneCode())){
//                throw new ServiceException("该库位不在物料对应的库区，请更换库位！");
//            }
//        }


//        locationService.updateByModel(location);
        return true;
    }


    @Override
    @Transactional
    public AjaxResult<List<Map<String, Object>>> scanReceiptCode(String receiptCode)  {
        List<Map<String, Object>> detail = receiptContainerHeaderMapper.getDetail(receiptCode, ShiroUtils.getWarehouseCode());
        return AjaxResult.success(detail);
    }

    @Override
    @Transactional
    public AjaxResult<List<Map<String, Object>>> scanAGVReceipt(String receiptCode)  {
        List<Map<String, Object>> detail = receiptContainerHeaderMapper.getAGVDetail(receiptCode, ShiroUtils.getWarehouseCode());
        return AjaxResult.success(detail);
    }

    @Override
    @Transactional
    public AjaxResult<List<Map<String, Object>>> getReceiptInfoByBill(String receiptCode)  {
        List<Map<String, Object>> detail = receiptContainerHeaderMapper.getReceiptInfoByBill(receiptCode, ShiroUtils.getWarehouseCode());
        return AjaxResult.success(detail);
    }

    @Override
    @Transactional
    public AjaxResult<List<Map<String, Object>>> getAGVReceiptInfoByBill(String receiptCode)  {
        List<Map<String, Object>> detail = receiptContainerHeaderMapper.getAGVReceiptInfoByBill(receiptCode, ShiroUtils.getWarehouseCode());
        return AjaxResult.success(detail);
    }


    @Override
    @Transactional
    public AjaxResult<List<Map<String, String>>> batchSave(List<ReceiptContainerView> list)  {
        if (list.size() < 1)    throw new ServiceException("收货明细是空！");
        List<Map<String, String>> returnValue = new ArrayList<>();
        checkContainer(list.get(0));
        if (checkLocationCode(list.get(0)) == true)
            locationService.updateStatus(list.get(0).getLocationCode(), "lock");
        ReceiptContainerHeader receiptContainerHeaderId = receiptContainerHeaderAdd(list.get(0));
        for (ReceiptContainerView receiptContainerView : list) {
            ReceiptDetail receiptDetail = receiptDetailQtyAdd(receiptContainerView.getReceiptDetailId(), receiptContainerView.getQty());
            receiptContainerDetailAdd(receiptContainerHeaderId.getId(), receiptDetail, receiptContainerView);
            returnValue.add(ReturnValue(receiptContainerView.getReceiptDetailId(), receiptDetail));
        }
        receiptHeaderService.receiptStatusUpdate(Integer.valueOf(returnValue.get(0).get("receiptId")), (short)200);
        return AjaxResult.success(returnValue);
    }

//    @Override
//    @Transactional
//    public AjaxResult<List<Map<String, String>>> mobileBatchSave(List<ReceiptContainerView> list) {
//        if (list.size() < 1)    throw new ServiceException("收货明细是空！");
//        checkContainer(list.get(0));
//        return innerBatchSave(list);
//    }


//    private AjaxResult<List<Map<String, String>>> innerBatchSave(List<ReceiptContainerView> list) {
//        locationService.updateStatus(list.get(0).getLocationCode(), "lock");
//        List<Map<String, String>> returnValue = new ArrayList<>();
//        ReceiptContainerHeader receiptContainerHeaderId = receiptContainerHeaderAdd(list.get(0));
//        for (ReceiptContainerView receiptContainerView : list) {
//            ReceiptDetail receiptDetail = receiptDetailQtyAdd(receiptContainerView.getReceiptDetailId(), receiptContainerView.getQty());
//            receiptContainerDetailAdd(receiptContainerHeaderId.getId(), receiptDetail, receiptContainerView);
//            returnValue.add(ReturnValue(receiptContainerView.getReceiptDetailId(), receiptDetail));
//        }
//        receiptHeaderService.receiptStatusUpdate(Integer.valueOf(returnValue.get(0).get("receiptId")), (short)200);
//        return AjaxResult.success(returnValue);
//    }

    /**入库组盘保存收货信息*/
    @Override
    @Transactional
    public AjaxResult<Map<String, String>> save(ReceiptContainerView record)  {
        //取出入库详单对应的物料编码和物料库区
        /*生成组盘明细前校验组盘明细里已有的组盘数量，已组盘数量加正在组盘的数量不能大于入库单明细条的数量 */
        ReceiptDetail rc=new ReceiptDetail();
        rc.setReceiptCode(record.getReceiptCode());
        rc.setWarehouseCode(ShiroUtils.getWarehouseCode());
        rc.setId(record.getReceiptDetailId());
        rc=receiptDetailService.selectFirstEntity(rc);
        record.setMaterialCode(rc.getMaterialCode());
        //找到细单的库区
        record.setZoneCode(rc.getZoneCode());
        if(record.getZoneCode()==null){
            throw new ServiceException("此单据没有分配库区，请分配库区");
        }
        ReceiptContainerDetail rcd = new ReceiptContainerDetail();
        rcd.setReceiptCode(record.getReceiptCode());
        rcd.setReceiptDetailId(rc.getId());
        rcd.setMaterialCode(record.getMaterialCode());
        List<ReceiptContainerDetail> rcdlist = receiptContainerDetailService.selectListEntityByEqual(rcd);
        BigDecimal sum =BigDecimal.ZERO;
        for(ReceiptContainerDetail item:rcdlist){
            sum = sum.add(item.getQty());
        }
        //sum2不能大于qty
        BigDecimal sum2 = sum.add(record.getQty());
        int s = sum2.compareTo(rc.getQty());
         if(s == 1){
             throw new ServiceException("子单据组盘的总数量不能超过单据数量,请检查入库详单数量和已组盘的数量！");
         }

        checkContainer(record);//检查容器
        if (checkLocationCode(record) == true)
            //autoLocationCode(record);//自动分配库位
        locationService.updateStatus(record.getLocationCode(), "lock");
        ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderAdd(record);
        ReceiptDetail receiptDetail = receiptDetailQtyAdd(record.getReceiptDetailId(), record.getQty());
        ReceiptContainerDetail receiptContainerDetail=receiptContainerDetailAdd(receiptContainerHeader.getId(), receiptDetail, record);

        receiptHeaderService.receiptStatusUpdate(receiptDetail.getReceiptId(), (short)200);
        return AjaxResult.success(ReturnValue(record.getReceiptDetailId(), receiptDetail));
    }

//    /**AGV满盘时入库组盘保存收货信息*/
//    @Override
//    @Transactional
//    public AjaxResult saveAGV(ReceiptContainerView record) {
//        String goodsShelfNo=null;
//        String containerCode=null;
//        String locationCode=null;
//        String code=null;
//        Container container=new Container();
//        Location location=new Location();
//        code=record.getReceiptContainerCode().substring(0,4);
//        //先查出同一货架上是否还有还有同物料的没达到满盘度的库存
//        Inventory inventory=new Inventory();
//        inventory=inventoryService.selectFirstInvertory(record,code);
//        if(inventory==null){
//            //查看同一货架是否还有空容器
//            container=containerService.selectFirstContainer(record.getReceiptContainerCode(),code);
//            if(container!=null){
//                containerCode=container.getCode();
//                location.setContainerCode(containerCode);
//                locationCode=locationService.selectFirstEntity(location).getCode();
//            }else {
//                //查找除了该货架的其他该物料库存
//                container.setCode(record.getReceiptContainerCode());
//                goodsShelfNo=containerService.selectFirstEntity(container).getGoodsShlfNo();
//                inventory=inventoryService.selectList(record,goodsShelfNo);
//                if(inventory!=null) {
//                    containerCode = inventory.getContainerCode();
//                    locationCode = inventory.getLocationCode();
//                }else {
//                    //当除了该容器就没有该物料的库存时
//                    container.setStatus("empty");
//                    container.setType("A");
//                    containerCode=containerService.selectContainer(container).getCode();
//                    location.setContainerCode(containerCode);
//                    locationCode=locationService.selectFirstEntity(location).getCode();
//                }
//            }
//        }else {
//            containerCode=inventory.getContainerCode();
//            locationCode=inventory.getLocationCode();
//        }
//        record.setReceiptContainerCode(containerCode);
//        record.setLocationCode(locationCode);
//        AjaxResult result = save(record);
//        return result;
//    }


    /**自动分配库位*/
    @Override
    @Transactional
    public AjaxResult autoLocationCode(ReceiptContainerView record) {

        Location location = new Location();
//        ReceiptDetail rc = receiptDetailService.selectEntityById(record.getReceiptDetailId());
//        Material material = materialService.getEnableMaterialByCode(rc.getMaterialCode());
        //判断是否有库位传过来，没有则自动分配
        if (StringUtils.isEmpty(record.getLocationCode())) {

             //以物料库区范围自动分配库位
            location.setWarehouseId(ShiroUtils.getWarehouseId());
            location.setZoneCode(record.getZoneCode());//物料库区
            location.setContainerCode("");
            location.setStatus("empty");
            location.setEnable(true);
            location.setDeleted(false);
            Location lo = locationService.selectFirstEntity(location);
            //库位分配规则
            if (lo == null) {
                throw new ServiceException("没有库位可以分配给容器了！");
            } else {
                record.setLocationCode(lo.getCode());
            }
        }else{
        //手动分配库位校验库区

            location.setWarehouseId(ShiroUtils.getWarehouseId());
            location.setCode(record.getLocationCode());
            location.setEnable(true);
            location.setDeleted(false);
            Location lo1 = locationService.selectFirstEntity(location);

            if(!lo1.getZoneCode().equals(record.getZoneCode())){
                throw new ServiceException("该库位不在物料对应的库区，请更换库位！");
            }

        }

        return AjaxResult.success("");
    }

    @Override
    public List<ReceiptContainerHeader> selectAgvListByLike(String shelfNo, String warehouseCode) {
        return receiptContainerHeaderMapper.selectAgvListByLike(shelfNo, warehouseCode);
    }

    @Override
    public int updateList(String shelfNo,String warehouseCode) {
        return receiptContainerHeaderMapper.updateList(shelfNo,warehouseCode);
    }


//    @Override
//    @Transactional
//    public AjaxResult<Map<String, String>> mobileSave(ReceiptContainerView record) {
//        checkContainer(record);
//        locationService.updateStatus(record.getLocationCode(), "lock");
//        ReceiptDetail receiptDetail = innerSave(record);
//        return AjaxResult.success(ReturnValue(record.getReceiptDetailId(), receiptDetail));
//    }

//    private ReceiptDetail innerSave(ReceiptContainerView record) {
//
//        ReceiptContainerHeader receiptContainerHeaderId = receiptContainerHeaderAdd(record);
//        ReceiptDetail receiptDetail = receiptDetailQtyAdd(record.getReceiptDetailId(), record.getQty());
//        receiptContainerDetailAdd(receiptContainerHeaderId.getId(), receiptDetail, record);
//        receiptHeaderService.receiptStatusUpdate(receiptDetail.getReceiptId(), (short)200);
//        return receiptDetail;
//    }


    /**
     *  增加组盘表头记录
     * @param record  组盘信息实体
     */
    private  ReceiptContainerHeader  receiptContainerHeaderAdd(ReceiptContainerView record)  {
        //根据托盘查询组盘表头记录
        ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
        receiptContainerHeader.setReceiptContainerCode(record.getReceiptContainerCode());
        List<ReceiptContainerHeader> list = receiptContainerHeaderMapper.selectUnCompletedReceiptContainer(receiptContainerHeader);
        if (list.size() < 1)
        {
            //从主单获取u8的仓库
            ReceiptHeader receiptHeader=new ReceiptHeader();
            receiptHeader.setCode(record.getReceiptCode());
            receiptHeader=receiptHeaderService.selectFirstEntity(receiptHeader);

            ReceiptDetail receiptDetail = receiptDetailService.selectEntityById(record.getReceiptDetailId());
            receiptContainerHeader = new ReceiptContainerHeader();
            receiptContainerHeader.setReceiptContainerCode(record.getReceiptContainerCode());
            receiptContainerHeader.setStatus((short)0);
            receiptContainerHeader.setTaskType(record.getTaskType());
            receiptContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
            receiptContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
            //赋值u8仓库
            receiptContainerHeader.setuWarehouseCode(receiptHeader.getuWarehouseCode());
            receiptContainerHeader.setCompanyId(receiptDetail.getCompanyId());
            receiptContainerHeader.setCompanyCode(receiptDetail.getCompanyCode());
            receiptContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
            receiptContainerHeader.setLocationCode(record.getLocationCode());
            receiptContainerHeader.setZoneCode(record.getZoneCode());
            this.insert(receiptContainerHeader);
        }
        else
        {
            receiptContainerHeader = list.get(0);
            if (receiptContainerHeader.getStatus() > (short)9)
                throw new ServiceException("容器已经生成任务，不能放物料了！");
        }
        return  receiptContainerHeader;
    }


    /**
     * 增加入库明细的收货数量
     * @param receiptDetailId
     * @param Qty
     * @return
     */
    public ReceiptDetail receiptDetailQtyAdd(Integer receiptDetailId, BigDecimal Qty)  {
        ReceiptDetail receiptDetail = new ReceiptDetail();
        receiptDetail.setId(receiptDetailId);
        receiptDetail = receiptDetailService.selectFirstEntity(receiptDetail);

            // 将入库单明细的收货数量 + 保存的数量，然后在存入明细表
            receiptDetail.setQtyCompleted(receiptDetail.getQtyCompleted().add(Qty));
            receiptDetail.setStatus((short) 200);
            if (receiptDetail.getQtyCompleted().compareTo(receiptDetail.getQty()) > 0)
                throw new ServiceException("收货数大于待收数量！");
            receiptDetailService.updateByModel(receiptDetail);

        return receiptDetail;
    }

//    /**
//     *  增加组盘表头记录
//     * @param ContainerCode  托盘编码
//     */
//    private  ReceiptContainerHeader  mobileReceiptContainerHeaderAdd(String ContainerCode)  {
//        //根据托盘查询组盘表头记录
//        ReceiptContainerHeader condition = new ReceiptContainerHeader();
//        condition.setReceiptContainerCode(ContainerCode);
//        ReceiptContainerHeader receiptContainerHeader = this.selectFirstEntity(condition);
//        if (receiptContainerHeader == null)
//        {
//            Location location = new Location();
//            location.setWarehouseId(ShiroUtils.getWarehouseId());
//            location.setContainerCode("");
//            location.setStatus("empty");
//            location.setEnable(true);
//            location.setDeleted(false);
//            location = locationService.selectFirstEntity(location);
//            if (location == null)
//            {
//                throw new ServiceException("没有库位可以存放容器了！");
//            }
//            else
//            {
//                location.setStatus("lock");
//                locationService.updateByModel(location);
//            }
//            receiptContainerHeader = new ReceiptContainerHeader();
//            receiptContainerHeader.setReceiptContainerCode(ContainerCode);
//            receiptContainerHeader.setStatus((short)0);
//            receiptContainerHeader.setTaskType((short)100);
//            receiptContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
//            receiptContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
//            receiptContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
//            receiptContainerHeader.setLocationCode(location.getCode());
//            this.insert(receiptContainerHeader);
//        }
//        else
//        {
//            if (receiptContainerHeader.getStatus() > (short)9)
//                throw new ServiceException("容器已经在上架中，不能放物料了！");
//        }
//        return  receiptContainerHeader;
//    }

    /**
     *  增加组盘明细记录
     * @param receiptContainerHeaderId
     * @param receiptDetail
     * @param record
     */
    private  ReceiptContainerDetail  receiptContainerDetailAdd(Integer receiptContainerHeaderId, ReceiptDetail receiptDetail, ReceiptContainerView record)  {
        // 根据表头ID和入库单明细ID找组盘明细
        ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
        receiptContainerDetail.setHeaderId(receiptContainerHeaderId);
        receiptContainerDetail.setReceiptDetailId(record.getReceiptDetailId());
        receiptContainerDetail = receiptContainerDetailService.selectFirstEntity(receiptContainerDetail);
        if (receiptContainerDetail == null)
        {
            Material material = materialService.getEnableMaterialByCode(receiptDetail.getMaterialCode());
            receiptContainerDetail = new ReceiptContainerDetail();
            receiptContainerDetail.setHeaderId(receiptContainerHeaderId);
            receiptContainerDetail.setReceiptCode(receiptDetail.getReceiptCode());
            receiptContainerDetail.setReceiptId(receiptDetail.getReceiptId());
            receiptContainerDetail.setReceiptDetailId(record.getReceiptDetailId());
            receiptContainerDetail.setMaterialCode(receiptDetail.getMaterialCode());
            receiptContainerDetail.setMaterialName(material.getName());
            receiptContainerDetail.setMaterialSpec(material.getSpecification());
            BigDecimal num=new BigDecimal(0);
            num=record.getQty();
            //物料库区为AGV的需要考虑是否满盘
            if(StringUtils.isNotEmpty(receiptDetail.getZoneCode()) && receiptDetail.getZoneCode().equals("AGV")){
                //查出与容器和物料对应的库存
                Inventory inventory=new Inventory();
                inventory.setMaterialCode(receiptDetail.getMaterialCode());
                inventory.setContainerCode(record.getReceiptContainerCode());
                inventory=inventoryService.selectFirstEntity(inventory);
                //查看容器与物料对应的满盘度
                ContainerCapacity containerCapacity=new ContainerCapacity();
                containerCapacity.setCode("AGV");
                containerCapacity.setMaterialCode(record.getMaterialCode());
                containerCapacity.setWarehouseCode(ShiroUtils.getWarehouseCode());
                containerCapacity=containerService.selectContainerCapacity(containerCapacity);
                num=containerCapacity.getUph();
                String qty=null;
                //如果没有库存
                if(inventory==null){
                    //物料满盘度大于单据数量时，组盘数量为单据数量，否则为满盘数量
                    if(num.intValue()-record.getQty().intValue()>=0){
                        num=record.getQty();
                    }
                }else {
                    //容器剩余数量大于单据数量时，组盘数量单据数量，否则为剩余数量
                    if(num.intValue()-inventory.getQty().intValue()-record.getQty().intValue()>0){
                        num=record.getQty();
                    }else {
                        throw new ServiceException("收货数量大于容器剩余数量，请调低收获数量!");
                    }

                }

            }
            receiptContainerDetail.setQty(num);
            receiptContainerDetail.setCreatedBy(ShiroUtils.getLoginName());
            receiptContainerDetail.setProject(receiptDetail.getProject());
            receiptContainerDetailService.insert(receiptContainerDetail);
        }
        else
        {
            receiptContainerDetail.setQty(receiptContainerDetail.getQty().add(record.getQty()));
            receiptContainerDetailService.updateByModel(receiptContainerDetail);
        }
        return receiptContainerDetail;
    }

    /**
     *  返回客户端的键值对
     * @param receiptDetailId
     * @param receiptDetail
     * @return
     */
    public Map<String, String>  ReturnValue(Integer receiptDetailId, ReceiptDetail receiptDetail)    {
        Map<String, String> returnValue = new HashMap<>();
        returnValue.put("id", receiptDetailId.toString());
        returnValue.put("receiptId", receiptDetail.getReceiptId().toString());
        returnValue.put("materialCode", receiptDetail.getMaterialCode());
        returnValue.put("qtyCompleted", receiptDetail.getQtyCompleted().toString());
        return  returnValue;
    }

    /**
     * 更改组盘状态
     * @param containerCode
     * @param status
     */
    @Override
    public void cancelReceiptContainer(String containerCode, Short status)  {
        //找到这个货箱
        ReceiptContainerHeader condition = new ReceiptContainerHeader();
        condition.setWarehouseId(ShiroUtils.getWarehouseId());
        condition.setReceiptContainerCode(containerCode);
        //在<20的状态下查找，本方法只在任务相关中才调用到
        List<ReceiptContainerHeader> shipmentContainerHeaders = receiptContainerHeaderMapper.selectUnCompletedReceiptContainer(condition);
        if(shipmentContainerHeaders != null && shipmentContainerHeaders.size() > 0){
            shipmentContainerHeaders.get(0).setStatus(status);
            this.updateByModel(shipmentContainerHeaders.get(0));
        }
    }

    @Override
    @Transactional
    public int insertTodayReceiptContainerHeader(ReceiptBill receiptBill, String receiptCode) {
        String receiptContainerCode = receiptBill.getReceiptContainerCode();
        String locationCode = receiptBill.getLocationCode();
        String compnayId = receiptBill.getCompanyId();
        String companyCode = receiptBill.getCompanyCode();
        ReceiptContainerHeader recorder = new ReceiptContainerHeader();
        recorder.setReceiptContainerCode(receiptContainerCode);
        recorder.setLocationCode(locationCode);
        recorder.setWarehouseId(ShiroUtils.getWarehouseId());
        recorder.setWarehouseCode(ShiroUtils.getWarehouseCode());
        recorder.setCompanyId(Integer.parseInt(compnayId));
        recorder.setCompanyCode(companyCode);
        recorder.setTaskType((short)100);
        recorder.setStatus((short) 0);
        recorder.setCreatedBy(ShiroUtils.getLoginName());
        ReceiptContainerHeader receiptContainerHeader = selectFirstEntity(recorder);
        if(receiptContainerHeader == null) {
            insert(recorder);
        } else {
            return receiptContainerHeader.getId();
        }

        locationService.updateStatus(locationCode, "lock");
        containerService.updateLocationCodeAndStatus(receiptContainerCode, locationCode, "some");
        return recorder.getId();
    }


}