wms / hhwms · Files

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

import com.huaheng.api.SSP.service.OrderAssignApiService;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.inventory.inventory.domain.Inventory;
import com.huaheng.pc.inventory.inventory.service.IInventoryService;
import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.IShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.IShipmentContainerHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.IShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.mapper.ShipmentHeaderMapperAuto;
import com.huaheng.pc.shipment.shipmentHeader.mapper.ShipmentHeaderMapper;
import com.huaheng.pc.system.dict.service.IDictDataService;
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.text.SimpleDateFormat;
import java.util.*;


/**
 * 出库单主 服务层实现
 * 
 * @author huaheng
 * @date 2018-08-19
 */
@Service
public class ShipmentHeaderServiceImpl implements IShipmentHeaderService {

    @Autowired
    IShipmentHeaderService shipmentHeaderService;
    @Autowired
    IShipmentDetailService shipmentDetailService;
    @Autowired
    IShipmentContainerDetailService shipmentContainerDetailService;
    @Autowired
    IShipmentContainerHeaderService shipmentContainerHeaderService;
	@Autowired
	IDictDataService dictDataService;
	@Resource
    private ShipmentHeaderMapper shipmentHeaderMapper;
    @Resource
    private ShipmentHeaderMapperAuto aotuMapper;
    @Autowired
    private OrderAssignApiService orderAssignApiService;
    @Autowired
    private IInventoryService iInventoryService;

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

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

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

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

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

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

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

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

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

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

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


    /**
     * 获取出库单头
     * @param condition
     * @return
     */
    @Override
    public List<ShipmentHeader> list(ShipmentHeader condition)  {
        condition.setWarehouseId(ShiroUtils.getWarehouseId());
        List<ShipmentHeader> result = this.selectListEntityByEqual(condition);
        return result;
    }

    /**
     * 新增出库头表
     * @param shipmentHeader
     * @return
     */
    @Override
    public AjaxResult insertHeader(ShipmentHeader shipmentHeader) {
        shipmentHeader.setId(null);
        shipmentHeader.setCode(createCode(shipmentHeader.getType()));
        shipmentHeader.setWarehouseId(ShiroUtils.getWarehouseId());
        shipmentHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        shipmentHeader.setCreated(null);
        shipmentHeader.setCreatedBy(ShiroUtils.getLoginName());
        shipmentHeader.setLastUpdated(null);
        shipmentHeader.setLastUpdatedBy(null);
        if (this.insert(shipmentHeader) > 0)
             return AjaxResult.success("");
        else
             return AjaxResult.error("");
    }

    /**
     * 修改出库头
     * @param shipmentHeader
     * @return
     */
    @Override
    public AjaxResult updateHeader(ShipmentHeader shipmentHeader) {
		ShipmentHeader sh = this.selectEntityById(shipmentHeader.getId());
        if(sh == null){
            return AjaxResult.error("未找到出库单头");
        }
        if(sh.getFirstStatus()>100){
            return AjaxResult.error("单据已进入订单池，不允许进行单据内容修改");
        }
        shipmentHeader.setCreated(null);
        shipmentHeader.setCreatedBy(null);
        shipmentHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
        shipmentHeader.setLastUpdated(null);
		if (this.updateByModel(shipmentHeader) > 0)
            return AjaxResult.success("");
        else
            return AjaxResult.error("");
    }

    /**
     * 删除出库单
     * @param id
     * @return
     */
    @Override
    @Transactional
    public AjaxResult<Integer> deleteHeaderAndDetail(Integer id)  {
        ShipmentHeader shipmentHeader = this.selectEntityById(id);
        if (shipmentHeader == null)  return AjaxResult.success("");
        ShipmentDetail condition = new ShipmentDetail();
        condition.setShipmentCode(shipmentHeader.getCode());
        if (shipmentHeader.getFirstStatus() < 100)
        {
            this.deleteById(id);
            shipmentDetailService.deleteByCondition(condition);
            return AjaxResult.success("");
        }
        else if (shipmentHeader.getFirstStatus() < 120)
        {
            ShipmentHeader headerRecord = new ShipmentHeader();
            headerRecord.setId(id);
            headerRecord.setDeleted(true);
            headerRecord.setLastUpdatedBy(ShiroUtils.getLoginName());
            this.updateByModel(headerRecord);

            ShipmentDetail detailRecord = new ShipmentDetail();
            detailRecord.setDeleted(true);
            detailRecord.setLastUpdatedBy(ShiroUtils.getLoginName());
            shipmentDetailService.updateByCondition(detailRecord, condition);
            return AjaxResult.success("成功删除");
        }
        else
        {
            return AjaxResult.error("单据状态超过120已经不能删除");
        }
    }


    /**
     * 根据Id更新这个单据的首尾状态
     * @param shipmentId
     * @return
     */
    @Override
   public AjaxResult updateShipmentStatus(int shipmentId)  {
        //获取这个单
        ShipmentHeader shipmentHeader = this.selectEntityById(shipmentId);
        if(shipmentHeader==null){
            return AjaxResult.error("单据未找到，Id:"+shipmentId);
        }
        //查询是否有生成出库货箱,如果有，则返回出库货箱的最高与最低状态
        Map<String,Integer> map = shipmentContainerHeaderService.getShipmentContainerMaxAndMinStatusByShipmentID(shipmentId);
        if(map==null){
            //说明没有货箱，则直接首位均为新建
            shipmentHeader.setFirstStatus(0);
            shipmentHeader.setLastStatus(0);
            this.updateByModel(shipmentHeader);
        }else {
            int firstStatus = map.get("maxStatus");
            int lastStatus = map.get("minStatus");
            if(firstStatus<20){
                shipmentHeader.setFirstStatus(200);
            }
            if(firstStatus==20){
                shipmentHeader.setFirstStatus(300);
            }
            if(firstStatus==30){
                shipmentHeader.setFirstStatus(500);
            }
            if(lastStatus<20){
                shipmentHeader.setLastStatus(200);
            }
            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(0);
            }
            this.updateByModel(shipmentHeader);
        }

        return AjaxResult.success("");

    }

    @Override
    public AjaxResult checkSatas(Integer headerId, Short status){
        ShipmentHeader shipmentHeader = this.selectEntityById(headerId);
        if (shipmentHeader == null)
        {
            return  AjaxResult.error("数据错误，没有表头！");
        }
        else if (shipmentHeader.getFirstStatus() > status)
        {
            return  AjaxResult.error(String .join("单据状态超过" + status + "已经不可修改！"));
        }
        else
        {
            return   AjaxResult.success("");
        }
    }

    @Override
    public AjaxResult checkSatas(String ShipmentCode, Short status)  {
        ShipmentHeader condition = new ShipmentHeader();
        condition.setCode(ShipmentCode);
        List<ShipmentHeader> shipmentHeaders = this.selectListEntityByEqual(condition);
        if (shipmentHeaders.size() < 1)
        {
            return  AjaxResult.error("数据错误，没有表头！");
        }
        else if (shipmentHeaders.get(0).getFirstStatus() > status)
        {
            return  AjaxResult.error("单据状态超过" + status + "已经不可修改！");
        }
        else
        {
            return   AjaxResult.success("");
        }
    }

    @Override
    @Transactional
    public AjaxResult<List<Map<String, Object>>> getShipDetail(String shipCode)  {
        ShipmentHeader shipmentHeader = new ShipmentHeader();
        shipmentHeader.setCode(shipCode);
        List<ShipmentHeader> list = this.selectListEntityByEqual(shipmentHeader);
        if (list.size() < 1)
            return  AjaxResult.error("出库单不存在！");
        else
            shipmentHeader = list.get(0);
        if (shipmentHeader.getLastStatus() >= 900)
            return AjaxResult.error("出库单已经完成，不能在收货！");
        if (shipmentHeader.getWarehouseId() != ShiroUtils.getWarehouseId())
            return AjaxResult.error("不是当前仓库的货物！");
        if (shipmentHeader.getFirstStatus() < 200)
        {
            shipmentHeader.setFirstStatus(200);
            this.updateByModel(shipmentHeader);
        }

        List<Map<String, Object>> detail = shipmentHeaderMapper.getShipDetail(shipCode);
        return AjaxResult.success(detail);
    }

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

    @Override
    public Integer createTodayShipmentHeader(String companyId, String companyCode) {
        ShipmentHeader shipmentHeader = new ShipmentHeader();
        String code =  createTodayCode();
        shipmentHeader.setCode(code);
        ShipmentHeader shipmentHeader1 = selectFirstEntity(shipmentHeader);
        if(shipmentHeader1 != null) {
            return shipmentHeader1.getId();
        }
        shipmentHeader.setId(null);
        shipmentHeader.setLastUpdated(null);
        shipmentHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
        shipmentHeader.setCreated(null);
        shipmentHeader.setCreatedBy(ShiroUtils.getLoginName());
        shipmentHeader.setWarehouseId(ShiroUtils.getWarehouseId());
        shipmentHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        shipmentHeader.setUploadStatus(0);
        shipmentHeader.setCompanyId(Integer.parseInt(companyId));
        shipmentHeader.setType("PO");
        shipmentHeader.setCompanyCode(companyCode);
        this.insert(shipmentHeader);
        return shipmentHeader.getId();
    }

    @Override
    public void statistics(Integer shipmentId) {
        ShipmentHeader shipmentHeader = selectEntityById(shipmentId);
        ShipmentDetail temp = new ShipmentDetail();
        temp.setShipmentId(shipmentId);
        List<ShipmentDetail> list = shipmentDetailService.selectListEntityByEqual(temp);
        if (list == null || list.size() == 0) {
            shipmentHeader.setTotalLines(0);
            shipmentHeader.setTotalQty(new BigDecimal("0"));
            updateByModel(shipmentHeader);
        }else{
            shipmentHeader.setTotalLines(list.size());
            BigDecimal total = new BigDecimal("0");
            for (ShipmentDetail item:list){
                total = total.add(item.getQty());
            }
            shipmentHeader.setTotalQty(total);
            updateByModel(shipmentHeader);
        }
    }

    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;
    }

    @Override
    public ShipmentHeader selectLastOne() {
        ShipmentHeader smh = shipmentHeaderMapper.selectLastOne();
        return smh;
    }

    @Override
    public ShipmentHeader getShipment(ShipmentHeader shipmentHeader) {
        ShipmentHeader smh = shipmentHeaderMapper.getShipment(shipmentHeader);
        return smh;
    }

    @Override
    public ShipmentHeader selectNosScanSSP(String code) {
        return shipmentHeaderMapper.selectNosScanSSP(code);
    }

    @Override
    public AjaxResult shipping(String code,String[] ids) {
        AjaxResult ajaxResult=new AjaxResult();
        ShipmentDetail shipmentDetail=new ShipmentDetail();
        shipmentDetail.setShipmentCode(code);
        HashSet<String> set=new HashSet();
        List<ShipmentDetail> shipmentDetails=new ArrayList<>();
        for(String id: ids) {
            shipmentDetail.setId(Integer.valueOf(id));
            ShipmentDetail shipmentDetai = shipmentDetailService.selectFirstEntity(shipmentDetail);
            String zc=shipmentDetai.getZoneCode();
            if (zc == null) {
                zc = "";
            }
            if(zc.equals("QG")){
                shipmentDetails.add(shipmentDetai);
            }
            set.add(zc);
        }
//        if(list.size()==0){
//            ajaxResult.setCode(200);
//        }else {
//            for (ShipmentDetail item : list) {
//                Inventory inventory=new Inventory();
//                inventory.setMaterialCode(item.getMaterialCode());
//                inventory.setProject(item.getProject());
//                inventory.setWarehouseCode(ShiroUtils.getWarehouseCode());
//                inventory=iInventoryService.selectFirstEntity(inventory);
//                if(inventory!=null){
//                    String zc=inventory.getZoneCode();
//                    item.setZoneCode(zc);
//                    shipmentDetailService.updateByModel(item);
//                String zc=item.getZoneCode();
//                if (zc == null) {
//                    zc = "";
//                }
//                     set.add(zc);
//
//            }
            if (set.size() == 1 && set.stream().anyMatch(X->X.equals("AGV"))) {
                ajaxResult.setCode(300);
            }
            if (!set.stream().anyMatch(X->X.equals("AGV"))) {
                ajaxResult.setCode(200);
            }
            if (set.size() > 1 && set.stream().anyMatch(X->X.equals("AGV"))) {
                ajaxResult.setCode(400);
            }

        if (set.stream().anyMatch(X->X.equals("QG"))) {
            ShipmentHeader item = this.selectNosScanSSP(code);
            if (item != null ){
                AjaxResult ajaxResults=orderAssignApiService.shipmentAssign(item,shipmentDetails);
                if(!ajaxResults.hasErr()){
                    ajaxResult.setMsg("单据下发成功");
                }else {
                    ajaxResult.setMsg(ajaxResults.getMsg());
                }
            }else {
                ajaxResult.setMsg("单据已下发");
            }
        }
//        if (set.stream().anyMatch(X->X.equals(""))) {
//            ajaxResult.setCode(500);
//            ajaxResult.setMsg("请先分配库区");
//        }
        return ajaxResult;
    }

    @Override
    public AjaxResult shippings(String code) {
        AjaxResult ajaxResult = new AjaxResult();
        ShipmentDetail shipmentDetail = new ShipmentDetail();
        shipmentDetail.setShipmentCode(code);
        HashSet<String> set = new HashSet();
        List<ShipmentDetail> list = shipmentDetailService.selectListEntityByEqual(shipmentDetail);
        List<ShipmentDetail> shipmentDetails=new ArrayList<>();
        if (list.size() == 0) {
            ajaxResult.setCode(200);
        } else {
            for (ShipmentDetail item : list) {
                String zc = item.getZoneCode();
                if (zc == null) {
                    zc = "";
                }
                if(zc.equals("QG")){
                    shipmentDetails.add(item);
                }
                set.add(zc);

            }
            if (set.size() == 1 && set.stream().anyMatch(X -> X.equals("AGV"))) {
                ajaxResult.setCode(300);
            }
            if (!set.stream().anyMatch(X -> X.equals("AGV"))) {
                ajaxResult.setCode(200);
            }
            if (set.size() > 1 && set.stream().anyMatch(X -> X.equals("AGV"))) {
                ajaxResult.setCode(400);
            }
        }
        if (set.stream().anyMatch(X -> X.equals("QG"))) {
            ShipmentHeader item = this.selectNosScanSSP(code);
            if (item != null) {
                AjaxResult ajaxResults = orderAssignApiService.shipmentAssign(item,shipmentDetails);
                if (!ajaxResults.hasErr()) {
                    ajaxResult.setMsg("单据下发成功");
                }
                else {
                    ajaxResult.setMsg(ajaxResults.getMsg());
                }
            } else {
                ajaxResult.setMsg("单据已下发");
            }
        }
        return ajaxResult;
    }

    @Override
    public List<ShipmentHeader> selectListByCreated() {
        return shipmentHeaderMapper.selectListByCreated();
    }

    private String createTodayCode()
    {
        String shipmentType = "PO";
        String code = null;
        Date now = new Date();
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
        String maxCode = shipmentHeaderMapper.createCode(shipmentType);
        boolean doDelete = false;
        if (maxCode != null) {
            ShipmentContainerDetail condition = new ShipmentContainerDetail();
            condition.setShipmentCode(maxCode);
            List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.selectListEntityByEqual(condition);
            if(shipmentContainerDetails == null || shipmentContainerDetails.size() == 0) {
                ShipmentHeader condition2 = new ShipmentHeader();
                condition2.setCode(maxCode);
                ShipmentHeader shipmentHeader = shipmentHeaderService.selectFirstEntity(condition2);
                ShipmentDetail condition3 = new ShipmentDetail();
                condition3.setShipmentId(shipmentHeader.getId());
                List<ShipmentDetail> shipmentDetails = shipmentDetailService.selectListEntityByEqual(condition3);
                shipmentHeaderService.deleteById(shipmentHeader.getId());
                for (ShipmentDetail shipmentDetail : shipmentDetails) {
                    shipmentDetailService.deleteById(shipmentDetail.getId());
                }
                doDelete = true;
            }
        }
        if (maxCode != null && maxCode.length() > 13 && maxCode.substring(maxCode.length() - 13, maxCode.length() - 5).equals(df.format(now)))
        {
//           if(doDelete) {
//                return maxCode;
//            } else {
//                Integer Count = Integer.valueOf(maxCode.substring(maxCode.length() - 5, maxCode.length()));
//                code = shipmentType + df.format(now) + String.format("%05d", Count + 1);
               code = shipmentType + df.format(now) + "00001";
//            }
        }
        else
        {
            code = shipmentType + df.format(now) + "00001";
        }
        return code;
    }

}