wms / wms_changshusanyi · Files

package com.huaheng.api.robot.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.robot.domain.RobotInfo;
import com.huaheng.api.wcs.domain.WcsTask;
import com.huaheng.api.wcs.service.taskInfo.TaskInfoService;
import com.huaheng.common.constant.HttpConstant;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.http.HttpUtils;
import com.huaheng.framework.aspectj.lang.annotation.ApiLogger;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.location.service.LocationService;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.station.domain.Station;
import com.huaheng.pc.config.station.service.StationService;
import com.huaheng.pc.config.zone.domain.Zone;
import com.huaheng.pc.config.zone.service.ZoneService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.monitor.job.task.AGVBean;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.ReceiptTaskService;
import com.huaheng.pc.task.taskHeader.service.ShipmentTaskService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import io.swagger.annotations.ApiOperation;
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.List;
import java.util.stream.Collectors;

@Service
public class RobotServiceImpl implements RobotService {

    @Resource
    TaskHeaderService taskHeaderService;
    @Resource
    AddressService addressService;
    @Resource
    MaterialService materialService;
    @Resource
    TaskDetailService taskDetailService;
    @Resource
    InventoryHeaderService inventoryHeaderService;
    @Resource
    InventoryDetailService inventoryDetailService;
    @Resource
    ZoneService zoneService;
    @Resource
    ContainerService containerService;
    @Resource
    StationService stationService;
    @Resource
    ShipmentTaskService shipmentTaskService;
    @Resource
    ReceiptTaskService receiptTaskService;
    @Resource
    TaskInfoService taskInfoService;
    @Resource
    LocationService locationService;


    @Override
    @ApiOperation("推送入库托盘信息")
    @ApiLogger(apiName = "推送入库托盘信息", from="ROBOT")
    public AjaxResult pushReceiptContainer(TaskHeader taskHeader,
                                       List<TaskDetail> taskDetailList, String warehouseCode) {
        String url = addressService.selectAddress(QuantityConstant.PUSH_RECEIPT_CONTAINER,
                warehouseCode, null);
        List<RobotInfo> robotInfoList = new ArrayList<>();
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getZoneCode, taskHeader.getZoneCode())
                .eq(InventoryDetail::getMaterialCode, taskHeader.getMaterialCode())
                .eq(InventoryDetail::getContainerCode, taskHeader.getContainerCode())
                .eq(InventoryDetail::getTaskQty, 0);
        List<InventoryDetail> inventoryDetailList =
                inventoryDetailService.list(inventoryDetailLambdaQueryWrapper1);
        for(TaskDetail taskDetail : taskDetailList) {
            RobotInfo robotInfo = new RobotInfo();
            robotInfo.setContainerCode(taskDetail.getContainerCode());
            robotInfo.setOrderNo(taskHeader.getOrderNo());
            robotInfo.setPort(taskHeader.getPort());
            robotInfo.setLine(taskHeader.getLine());
            robotInfo.setMaterialCode(taskDetail.getMaterialCode());
            robotInfo.setMaterialCodePLC(taskHeader.getMaterialCodePLC());
            robotInfo.setQty(taskDetail.getQty().intValue());
            robotInfo.setSn(taskDetail.getSn());
            robotInfo.setPosition(taskDetail.getPosition());
            robotInfo.setIsPrint(taskDetail.getIsPrint());
            robotInfo.setArea(taskHeader.getArea());
            robotInfo.setQc(0);
            robotInfo.setType(taskHeader.getType());
            robotInfoList.add(robotInfo);
        }
        for(InventoryDetail inventoryDetail : inventoryDetailList) {
            RobotInfo robotInfo = new RobotInfo();
            robotInfo.setContainerCode(inventoryDetail.getContainerCode());
            robotInfo.setOrderNo(taskHeader.getOrderNo());
            robotInfo.setPort(taskHeader.getPort());
            robotInfo.setLine(taskHeader.getLine());
            robotInfo.setMaterialCode(inventoryDetail.getMaterialCode());
            robotInfo.setMaterialCodePLC(taskHeader.getMaterialCodePLC());
            robotInfo.setQty(inventoryDetail.getQty().intValue());
            robotInfo.setSn(inventoryDetail.getSn());
            robotInfo.setPosition(inventoryDetail.getPosition());
            robotInfo.setIsPrint(inventoryDetail.getIsPrint());
            robotInfo.setArea(taskHeader.getArea());
            robotInfo.setQc(0);
            robotInfo.setType(taskHeader.getType());
            robotInfoList.add(robotInfo);
        }
        if(taskDetailList != null && taskDetailList.size() == 0
        && inventoryDetailList != null && inventoryDetailList.size() == 0) {
            RobotInfo robotInfo = new RobotInfo();
            robotInfo.setContainerCode(taskHeader.getContainerCode());
            robotInfo.setOrderNo(taskHeader.getOrderNo());
            robotInfo.setPort(taskHeader.getPort());
            robotInfo.setLine(taskHeader.getLine());
            robotInfo.setMaterialCode(taskHeader.getMaterialCode());
            robotInfo.setMaterialCodePLC(taskHeader.getMaterialCodePLC());
            robotInfo.setQty(0);
            robotInfo.setSn("");
            robotInfo.setPosition(0);
            robotInfo.setIsPrint(0);
            robotInfo.setArea(taskHeader.getArea());
            robotInfo.setQc(0);
            robotInfo.setType(taskHeader.getType());
            robotInfoList.add(robotInfo);
        }
        JSONArray jsonArray = getJSONArrayByList(robotInfoList);
        String JsonParam = jsonArray.toJSONString();
        System.out.println(JsonParam);
        String result = HttpUtils.bodypost("pushReceiptContainer", url, JsonParam);
        if(StringUtils.isEmpty(result)) {
            int pushErrorTime = taskHeader.getPushErrorTime();
            pushErrorTime ++;
            taskHeader.setPushErrorTime(pushErrorTime);
            taskHeaderService.updateById(taskHeader);
            if(result == null) {
                result = "推送入库托盘信息失败";
            }
            return AjaxResult.error(result);
        }
        AjaxResult ajaxResult = JSON.parseObject(result, AjaxResult.class);
        if(ajaxResult.getCode() != HttpConstant.OK) {
            int pushErrorTime = taskHeader.getPushErrorTime();
            pushErrorTime ++;
            taskHeader.setPushErrorTime(pushErrorTime);
            taskHeaderService.updateById(taskHeader);
            return AjaxResult.error(ajaxResult.getMsg());
        }
        int push = taskHeader.getPush();
        push++;
        taskHeader.setPush(push);
        taskHeaderService.updateById(taskHeader);
        return AjaxResult.success("发送入库托盘数据成功");
    }

    @Override
    @ApiOperation("推送出库托盘信息")
    @ApiLogger(apiName = "推送出库托盘信息", from="ROBOT")
    public AjaxResult pushShipmentContainer(TaskHeader taskHeader,
                                    List<InventoryDetail> inventoryDetailList, String warehouseCode) {
        String url = addressService.selectAddress(QuantityConstant.PUSH_SHIPMENT_CONTAINER,
                warehouseCode, null);
        List<RobotInfo> robotInfoList = new ArrayList<>();
        for(InventoryDetail inventoryDetail : inventoryDetailList) {
            RobotInfo robotInfo = new RobotInfo();
            robotInfo.setContainerCode(inventoryDetail.getContainerCode());
            robotInfo.setOrderNo(taskHeader.getOrderNo());
            robotInfo.setPort(taskHeader.getPort());
            robotInfo.setLine(taskHeader.getLine());
            robotInfo.setMaterialCode(inventoryDetail.getMaterialCode());
            robotInfo.setMaterialCodePLC(taskHeader.getMaterialCodePLC());
            robotInfo.setQty(inventoryDetail.getQty().intValue());
            robotInfo.setSn(inventoryDetail.getSn());
            robotInfo.setQc(inventoryDetail.getQc());
            robotInfo.setPosition(inventoryDetail.getPosition());
            robotInfo.setIsPrint(inventoryDetail.getIsPrint());
            robotInfo.setArea(taskHeader.getArea());
            robotInfoList.add(robotInfo);
        }
        JSONArray jsonArray = getJSONArrayByList(robotInfoList);
        String JsonParam = jsonArray.toJSONString();
        System.out.println(JsonParam);
        String result = HttpUtils.bodypost("pushShipmentContainer", url, JsonParam);
        if(StringUtils.isEmpty(result)) {
            int pushErrorTime = taskHeader.getPushErrorTime();
            pushErrorTime ++;
            taskHeader.setPushErrorTime(pushErrorTime);
            taskHeaderService.updateById(taskHeader);
            if(result == null) {
                result = "推送出库托盘信息失败";
            }
            return AjaxResult.error(result);
        }
        AjaxResult ajaxResult = JSON.parseObject(result, AjaxResult.class);
        if(ajaxResult.getCode() != HttpConstant.OK) {
            int pushErrorTime = taskHeader.getPushErrorTime();
            pushErrorTime ++;
            taskHeader.setPushErrorTime(pushErrorTime);
            taskHeaderService.updateById(taskHeader);
            return AjaxResult.error(ajaxResult.getMsg());
        }
        int push = taskHeader.getPush();
        push++;
        taskHeader.setPush(push);
        taskHeaderService.updateById(taskHeader);
        return AjaxResult.success("发送出库托盘数据成功");
    }

    /**
     * 根据List获取到对应的JSONArray
     * @param list
     * @return
     */
    public static JSONArray getJSONArrayByList(List<?> list){
        JSONArray jsonArray = new JSONArray();
        if (list==null ||list.isEmpty()) {
            return jsonArray;//nerver return null
        }

        for (Object object : list) {
            jsonArray.add(object);
        }
        return jsonArray;
    }

    @Override
    public AjaxResult back(String containerCode) {
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode);
        taskHeaderLambdaQueryWrapper.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        if(taskHeader == null) {
            return AjaxResult.error("没有找到任务，不允许回库");
        }
        int back = taskHeader.getBack();
        if(back == 1) {
            return AjaxResult.success("允许回库");
        }
        return AjaxResult.error("不允许回库");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult innerAddShipmentDetail(String containerCode, String materialCode, String port, String qty,
                                             String sn, String position, String isPrint, String area) {
        String warehouseCode = "CS0001";
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)
                .eq(TaskHeader::getContainerCode, containerCode)
                .eq(TaskHeader::getArea, area)
                .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                .eq(TaskHeader::getPort, port);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        if (taskHeader == null) {
            return AjaxResult.error("没有找到任务");
        }

        LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getContainerCode, containerCode)
                .eq(InventoryHeader::getWarehouseCode, warehouseCode);
        InventoryHeader inventoryHeader = inventoryHeaderService.getOne(inventoryHeaderLambdaQueryWrapper);
        if(inventoryHeader == null) {
            return AjaxResult.error("没有找到库存头");
        }
        int headerId = inventoryHeader.getId();
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getInventoryHeaderId, headerId)
                .eq(InventoryDetail::getWarehouseCode, warehouseCode)
                .eq(InventoryDetail::getMaterialCode, materialCode)
                .eq(InventoryDetail::getQty, qty)
                .eq(InventoryDetail::getPosition, position);
        InventoryDetail inventoryDetail = inventoryDetailService.getOne(inventoryDetailLambdaQueryWrapper);
        if(inventoryDetail == null) {
            return AjaxResult.error("没有找到库存详情");
        }

        BigDecimal taskQty = new BigDecimal(qty);
        Material material = materialService.findAllByCode(materialCode, warehouseCode);
        TaskDetail taskDetail = new TaskDetail();
        taskDetail.setTaskId(taskHeader.getId());
        if (isPrint != null) {
            taskDetail.setIsPrint(Integer.parseInt(isPrint));
        }
        if (position != null) {
            taskDetail.setPosition(Integer.parseInt(position));
        }
        taskDetail.setQty(taskQty);
        taskDetail.setSn(sn);
        taskDetail.setArea(area);
        taskDetail.setPort(port);
        taskDetail.setMaterialCode(materialCode);
        taskDetail.setMaterialName(material.getName());
        taskDetail.setTaskType(taskHeader.getTaskType());
        taskDetail.setWarehouseCode(taskHeader.getWarehouseCode());
        taskDetail.setCompanyCode(taskHeader.getCompanyCode());
        taskDetail.setFromLocation(taskHeader.getFromLocation());
        taskDetail.setToLocation(taskHeader.getToLocation());
        taskDetail.setInternalTaskType(taskHeader.getInternalTaskType());
        taskDetail.setContainerCode(taskHeader.getContainerCode());

        LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        taskDetailLambdaQueryWrapper1.eq(TaskDetail::getTaskId, taskHeader.getId())
                .eq(TaskDetail::getMaterialCode, materialCode)
                .eq(TaskDetail::getPosition, position);
        TaskDetail taskDetail1 = taskDetailService.getOne(taskDetailLambdaQueryWrapper1);
        if(taskDetail1 != null) {
            return  AjaxResult.success("减少物料成功, 物料已经存在");
        }

        try {
            boolean result = taskDetailService.save(taskDetail);
            if (!result) {
                throw new ServiceException("减少物料失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ServiceException("减少物料失败, 没有这个库存");
        }
        boolean result = inventoryDetailService.removeById(inventoryDetail);
        if(!result) {
            throw new ServiceException("库存详情删除失败");
        }
        inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getInventoryHeaderId, headerId)
                .eq(InventoryDetail::getWarehouseCode, warehouseCode)
                .eq(InventoryDetail::getMaterialCode, materialCode);
        List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if(inventoryDetailList != null && inventoryDetailList.size() > 0) {
            int size = inventoryDetailList.size();
            inventoryHeader.setTotalQty(new BigDecimal(size));
            inventoryHeader.setTotalLines(size);
            inventoryHeader.setContainerStatus(QuantityConstant.STATUS_CONTAINER_SOME);
            LambdaQueryWrapper<InventoryHeader> wrapper = Wrappers.lambdaQuery();
            wrapper.eq(InventoryHeader::getId, inventoryHeader.getId());
            result = inventoryHeaderService.update(inventoryHeader, wrapper);
            if(!result) {
                throw new ServiceException("减少物料失败, 更新库存头失败");
            }
        } else {
            result = inventoryHeaderService.removeById(inventoryHeader);
            if(!result) {
                throw new ServiceException("减少物料失败, 移除库存头失败");
            }
            int size = inventoryDetailList.size();
            if(size == 0) {
                taskHeader.setBack(1);
                result = taskHeaderService.updateById(taskHeader);
                if(!result) {
                    throw new ServiceException("减少物料失败, 让任务返回失败");
                }
            }
        }
        return AjaxResult.success("减少物料成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult innerAddReceiptDetail(String containerCode, String materialCode, String port, String qty,
                                             String sn, String position, String isPrint, String area, int qc, int type) {
        String warehouseCode = "CS0001";
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT)
                .eq(TaskHeader::getContainerCode, containerCode)
                .eq(TaskHeader::getArea, area)
                .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                .eq(TaskHeader::getPort, port);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        if(taskHeader == null) {
            taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_WHOLERECEIPT)
                    .eq(TaskHeader::getContainerCode, containerCode)
                    .eq(TaskHeader::getArea, area)
                    .ne(TaskHeader::getOrderNo, "")
                    .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                    .eq(TaskHeader::getPort, port);
            taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        }
        if(taskHeader == null) {
            return AjaxResult.error("没有找到任务");
        }

        BigDecimal taskQty = new BigDecimal(qty);
        Material material = materialService.findAllByCode(materialCode, warehouseCode);
        TaskDetail taskDetail = new TaskDetail();
        taskDetail.setTaskId(taskHeader.getId());
        taskDetail.setQty(taskQty);
        taskDetail.setQc(qc);
        taskDetail.setSn(sn);
        if(position != null) {
            taskDetail.setPosition(Integer.parseInt(position));
        }
        if(isPrint != null) {
            taskDetail.setIsPrint(Integer.parseInt(isPrint));
        }
        taskDetail.setMaterialCode(materialCode);
        taskDetail.setMaterialName(material.getName());
        taskDetail.setTaskType(taskHeader.getTaskType());
        taskDetail.setWarehouseCode(taskHeader.getWarehouseCode());
        taskDetail.setCompanyCode(taskHeader.getCompanyCode());
        taskDetail.setType(type);
        taskDetail.setFromLocation(taskHeader.getFromLocation());
        taskDetail.setToLocation(taskHeader.getToLocation());
        taskDetail.setInternalTaskType(taskHeader.getInternalTaskType());
        taskDetail.setContainerCode(taskHeader.getContainerCode());
        LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        taskDetailLambdaQueryWrapper1.eq(TaskDetail::getTaskId, taskHeader.getId())
                                    .eq(TaskDetail::getMaterialCode, materialCode)
                                    .eq(TaskDetail::getPosition, position);
        TaskDetail taskDetail1 = taskDetailService.getOne(taskDetailLambdaQueryWrapper1);
        if(taskDetail1 != null) {
          return  AjaxResult.success("增加物料成功, 物料已经存在");
        }
        try {
            boolean result = taskDetailService.save(taskDetail);
            if (!result) {
                throw new ServiceException("增加物料失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ServiceException("增加物料失败");
        }
        LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskDetailLambdaQueryWrapper.eq(TaskDetail::getTaskId, taskHeader.getId());
        List<TaskDetail> taskDetailList = taskDetailService.list(taskDetailLambdaQueryWrapper);
        int size = taskDetailList.size();
        int maxContainer = material.getMaxContainer();
        if(area.equals("4")) {
            maxContainer = material.getMax();
        }
        if(qc == QuantityConstant.QC_CHECK) {
            taskHeader.setBack(1);
            boolean result = taskHeaderService.updateById(taskHeader);
        }
        if(maxContainer == size) {
            taskHeader.setBack(1);
            boolean result = taskHeaderService.updateById(taskHeader);
            if(!result) {
                throw new ServiceException("增加物料失败, 让任务返回失败");
            }
        } else if(maxContainer < size) {
            throw new ServiceException("增加物料失败, 已经超出托盘最大数量");
        }
        return AjaxResult.success("增加物料成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult innerBack(WcsTask wcsTask) {
        String containerCode = wcsTask.getContainerCode();
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        //根据容器号查找
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode);
        taskHeaderLambdaQueryWrapper.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        if(taskHeader == null) {
            return AjaxResult.error("没有找到任务，不允许回库");
        }
        int back = taskHeader.getBack();
        if(back == 1) {
            return AjaxResult.success("允许回库");
        }
        return AjaxResult.error("任务ID:" + taskHeader.getId() + "不允许回库");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult innerCallShipment(String line, String materialCode, String qty,
                                        String area, int materialCodePLC, String orderNo) {
        String warehouseCode = "CS0001";
        LambdaQueryWrapper<Zone> zoneLambdaQueryWrapper = Wrappers.lambdaQuery();
        zoneLambdaQueryWrapper.eq(Zone::getArea, area);
        Zone zone = zoneService.getOne(zoneLambdaQueryWrapper);
        String zoneCode = zone.getCode();

        LambdaQueryWrapper<Station> stationLambdaQueryWrapper = Wrappers.lambdaQuery();
        stationLambdaQueryWrapper.eq(Station::getArea, area)
                .eq(Station::getLine, line);
        List<Station> stationList = stationService.list(stationLambdaQueryWrapper);
        if(stationList == null || stationList.size() == 0) {
            return AjaxResult.error("区域和线体不正确");
        }
        List<String> portCodeList = stationList.stream().map(t->t.getCode()).collect(Collectors.toList());
        if(portCodeList == null || portCodeList.size() == 0) {
            return AjaxResult.error("线体编码或者区域不正确，没有找到对应出口");
        }
        int areaInt = Integer.parseInt(area);
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getZoneCode, zoneCode)
                                    .eq(InventoryDetail::getMaterialCode, materialCode)
                                    .eq(InventoryDetail::getTaskQty, 0);
        List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if(inventoryDetailList == null || inventoryDetailList.size() == 0) {
            return AjaxResult.error("没有对应库存");
        }
        List<String> containerList = inventoryDetailList.stream().
                map(t -> t.getContainerCode()).collect(Collectors.toList());
        containerList = containerList.stream().distinct().collect(Collectors.toList());
        List<String> removeContainerList = new ArrayList<>();
        for(String containerCode : containerList) {
            Container container = containerService.getContainerByCode(containerCode, warehouseCode);
            if(!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_SOME)) {
                removeContainerList.add(containerCode);
            }
        }
        containerList.removeAll(removeContainerList);
        String port = null;
        if(portCodeList.size() > 1) {
            for (String portCode : portCodeList) {
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper2 = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper2.eq(TaskHeader::getPort, portCode)
                        .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT,
                                QuantityConstant.TASK_TYPE_WHOLESHIPMENT)
                        .eq(TaskHeader::getMaterialCode, materialCode)
                        .eq(TaskHeader::getArea, area)
                        .eq(TaskHeader::getBack, 0)
                        .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
                TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper2);
                if (taskHeader != null) {
                    LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
                    inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getMaterialCode, materialCode)
                            .eq(InventoryDetail::getContainerCode, taskHeader.getContainerCode());
                    List<InventoryDetail> inventoryDetailList1 =
                            inventoryDetailService.list(inventoryDetailLambdaQueryWrapper1);
                    if (inventoryDetailList1 != null && inventoryDetailList1.size() > 0) {
                        return pushShipmentContainer(taskHeader, inventoryDetailList1, warehouseCode);
                    }
                }
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper3 = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper3.eq(TaskHeader::getPort, portCode)
                        .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT,
                                QuantityConstant.TASK_TYPE_WHOLESHIPMENT)
                        .eq(TaskHeader::getArea, area)
                        .eq(TaskHeader::getBack, 0)
                        .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
                taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper3);
                if (taskHeader == null) {
                    port = portCode;
                }
                if(port != null) {
                    break;
                }
            }

        } else {
            port = portCodeList.get(0);
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper2 = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper2.eq(TaskHeader::getPort, port)
                    .eq(TaskHeader::getArea, area)
                    .eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)
                    .eq(TaskHeader::getMaterialCode, materialCode)
                    .eq(TaskHeader::getBack, 0)
                    .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
            TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper2);
            if(taskHeader != null) {
                LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskDetailLambdaQueryWrapper.eq(TaskDetail::getTaskId, taskHeader.getId());
                String containerCoe = taskHeader.getContainerCode();
                LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
                inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getZoneCode, zoneCode)
                        .eq(InventoryDetail::getMaterialCode, materialCode)
                        .eq(InventoryDetail::getContainerCode, containerCoe)
                        .eq(InventoryDetail::getTaskQty, 0);
                List<InventoryDetail> inventoryDetailList1 =
                        inventoryDetailService.list(inventoryDetailLambdaQueryWrapper1);
                List<TaskDetail> taskDetailList = taskDetailService.list(taskDetailLambdaQueryWrapper);
                if (taskDetailList != null && taskDetailList.size() >= 0) {
                    int size = taskDetailList.size();
                    if (size == 0) {
                        return AjaxResult.error("不要重复请求出库");
                    }
                    int inventorySize = inventoryDetailList1.size();
                    if (inventorySize > 0) {
                        taskHeader.setOrderNo(orderNo);
                        taskHeaderService.updateById(taskHeader);
                        return pushShipmentContainer(taskHeader, inventoryDetailList1, warehouseCode);
                    }  else {
                        throw new ServiceException("托盘没有库存了");
                    }
                }
            } else {
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper3 = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper3.eq(TaskHeader::getPort, port)
                        .eq(TaskHeader::getArea, area)
                        .eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)
                        .eq(TaskHeader::getBack, 0)
                        .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
                taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper3);
                if(taskHeader != null) {
                    taskHeader.setBack(1);
                    taskHeaderService.updateById(taskHeader);
                }
            }
        }
        if(port == null) {
            return AjaxResult.error("没有出库口可以满足出库");
        }
        if(containerList != null && containerList.size() > 0) {
            Container container = containerService.getContainerByCode(
                    containerList.get(0), warehouseCode);
            String containerCode = container.getCode();
            String locationCode = container.getLocationCode();
            return shipmentTaskService.createPickingTask(containerCode, locationCode,
                    materialCode, warehouseCode, port, materialCodePLC, orderNo, line, 0);
        }

        return AjaxResult.error("没有托盘可以满足出库");
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult innerCallReceipt(String line, String materialCode, String qty, String area,
                                       int materialCodePLC, String orderNo, int qc, int type) {
        String warehouseCode = "CS0001";
        LambdaQueryWrapper<Zone> zoneLambdaQueryWrapper = Wrappers.lambdaQuery();
        zoneLambdaQueryWrapper.eq(Zone::getArea, area);
        Zone zone = zoneService.getOne(zoneLambdaQueryWrapper);
        String zoneCode = zone.getCode();
        int areaInt = Integer.parseInt(area);
        LambdaQueryWrapper<Station> stationLambdaQueryWrapper = Wrappers.lambdaQuery();
        stationLambdaQueryWrapper.eq(Station::getArea, area)
                .eq(Station::getLine, line);
        List<Station> stationList = stationService.list(stationLambdaQueryWrapper);
        List<String> portCodeList = stationList.stream().map(t->t.getCode()).collect(Collectors.toList());
        if(portCodeList == null || portCodeList.size() == 0) {
            return AjaxResult.error("线体编码或者区域不正确，没有找到对应入口");
        }
        String port = null;
        Material material = materialService.findAllByCode(materialCode, warehouseCode);
        int maxContainer = material.getMaxContainer();
        if(area.equals("4")) {
            maxContainer = material.getMax();
        }
        if(portCodeList.size() > 1) {
            for (String portCode : portCodeList) {
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper2 = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper2.eq(TaskHeader::getPort, portCode)
                        .eq(TaskHeader::getMaterialCode, materialCode)
                        .eq(TaskHeader::getArea, area)
                        .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT,
                                QuantityConstant.TASK_TYPE_WHOLERECEIPT)
                        .eq(TaskHeader::getBack, 0)
                        .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
                TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper2);
                if (taskHeader != null) {
                    LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                    taskDetailLambdaQueryWrapper.eq(TaskDetail::getTaskId, taskHeader.getId());
                    List<TaskDetail> taskDetailList = taskDetailService.list(taskDetailLambdaQueryWrapper);
                    if (taskDetailList != null && taskDetailList.size() > 0) {
                        int size = taskDetailList.size();
                        if (size == 0) {
                            return AjaxResult.error("不要重复请求入库");
                        }
                        if (maxContainer > size) {
                            pushReceiptContainer(taskHeader, taskDetailList, warehouseCode);
                        } else if (maxContainer == size) {

                        } else {
                            throw new ServiceException("任务详情 超过托盘总数");
                        }
                    }
                } else {
                    port = portCode;
                    break;
                }
            }
        } else {
            port = portCodeList.get(0);
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper2 = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper2.eq(TaskHeader::getPort, port)
                    .eq(TaskHeader::getArea, area)
                    .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT,
                            QuantityConstant.TASK_TYPE_WHOLERECEIPT)
                    .eq(TaskHeader::getMaterialCode, materialCode)
                    .eq(TaskHeader::getBack, 0)
                    .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
            TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper2);
            if(taskHeader != null) {
                LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskDetailLambdaQueryWrapper.eq(TaskDetail::getTaskId, taskHeader.getId());
                List<TaskDetail> taskDetailList = taskDetailService.list(taskDetailLambdaQueryWrapper);
                if (taskDetailList != null && taskDetailList.size() >= 0) {
                    int size = taskDetailList.size();
                    if (size == 0) {
                        return AjaxResult.error("不要重复请求入库");
                    }
                    if (maxContainer > size) {
                        taskHeader.setOrderNo(orderNo);
                        taskHeaderService.updateById(taskHeader);
                        return pushReceiptContainer(taskHeader, taskDetailList, warehouseCode);
                    } else if (maxContainer == size) {

                    } else {
                        throw new ServiceException("任务详情 超过托盘总数");
                    }
                }
            } else {
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper3 = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper3.eq(TaskHeader::getPort, port)
                        .eq(TaskHeader::getArea, area)
                        .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT,
                                QuantityConstant.TASK_TYPE_WHOLERECEIPT)
                        .eq(TaskHeader::getBack, 0)
                        .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
                List<TaskHeader> taskHeaderList = taskHeaderService.list(taskHeaderLambdaQueryWrapper3);
                if(taskHeaderList.size() > 1) {
                    taskHeader = taskHeaderList.get(0);
                    if (taskHeader != null) {
                        taskHeader.setBack(1);
                        taskHeaderService.updateById(taskHeader);
                    }
                } else {
                    taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper3);
                    if (taskHeader != null) {
                        taskHeader.setBack(1);
                        taskHeaderService.updateById(taskHeader);
                    }
                }
            }
        }
        if(port == null) {
            return AjaxResult.error("没有入库口可以满足入库");
        }

        if(areaInt == 5 || areaInt == 6 || areaInt == 8 || areaInt == 9) {
            Station station = stationList.get(0);
            String stationCode = station.getCode();
            String containerCode = taskInfoService.getStationPallet(stationCode, area);
            return receiptTaskService.createWholeReceiptTask(containerCode,
                    materialCode, warehouseCode, port, line, area, orderNo, materialCodePLC, type);
        }
        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY)
                .ne(Container::getLocationCode, "")
                .eq(Container::getArea, area);
        List<Location> list = containerService.getEmptyContainerInLocation(
                zoneCode, "","", warehouseCode);
        List<String> emptyContainerCodeList = list.stream().map(t->t.getContainerCode()).collect(Collectors.toList());
        List<String> removeContainerList = new ArrayList<>();
        for(String containerCode : emptyContainerCodeList) {
            Container container = containerService.getContainerByCode(containerCode, warehouseCode);
            if(container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
                removeContainerList.add(containerCode);
            }
        }
        emptyContainerCodeList.removeAll(removeContainerList);

        if(emptyContainerCodeList != null && emptyContainerCodeList.size() > 0) {
            Container container = containerService.getContainerByCode(emptyContainerCodeList.get(0), warehouseCode);
            int maxEmpty = container.getMaxEmpty();
            if(qc == QuantityConstant.QC_CHECK) {
                maxEmpty = 0;
            }
            if(emptyContainerCodeList.size() < maxEmpty) {
                String containerCode = container.getCode();
                String locationCode = container.getLocationCode();
                return receiptTaskService.createSuppleReceiptTask(containerCode, locationCode,
                        materialCode, warehouseCode, port, line, area, orderNo, materialCodePLC, qc, type);
            }

        }

        String sql = "SELECT a.containerCode, a.qty from  " +
                "(SELECT containerCode, sum(qty) as qty  FROM `inventory_detail` " +
                "where materialCode = '%s' and zoneCode = '%s'  GROUP BY containerCode) as a where %s > a.qty ";
        sql = String.format(sql, materialCode, zoneCode, maxContainer);
        List<InventoryDetail> inventoryDetailList = inventoryDetailService.selectBysql(sql);
        if(inventoryDetailList != null &&  inventoryDetailList.size() > 0) {
            List<String> containerList = inventoryDetailList.stream().
                    map(t -> t.getContainerCode()).collect(Collectors.toList());
            String containerCode = containerList.get(0);
            Container container = containerService.getContainerByCode(containerCode, warehouseCode);
            String locationCode = container.getLocationCode();
            return receiptTaskService.createSuppleReceiptTask(containerCode, locationCode,
                    materialCode, warehouseCode, port, line, area, orderNo, materialCodePLC, qc, type);
        }
        if(emptyContainerCodeList != null && emptyContainerCodeList.size() > 0) {
            Container container = containerService.getContainerByCode(
                    emptyContainerCodeList.get(0), warehouseCode);
            String containerCode = container.getCode();
            String locationCode = container.getLocationCode();
            return receiptTaskService.createSuppleReceiptTask(containerCode, locationCode,
                    materialCode, warehouseCode, port, line, area, orderNo, materialCodePLC, qc, type);

        }
        return AjaxResult.error("没有托盘可以满足入库");
    }

    @Override
    public AjaxResult pushAGVTask(TaskHeader taskHeader) {
        String warehouseCode = taskHeader.getWarehouseCode();
        String url = addressService.selectAddress(QuantityConstant.PUSH_AGV_TASK,
                warehouseCode, null);
        LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskDetailLambdaQueryWrapper.eq(TaskDetail::getTaskId, taskHeader.getId());
        List<TaskDetail> taskDetailList = taskDetailService.list(taskDetailLambdaQueryWrapper);
        if(taskDetailList.size() == 0) {
            return AjaxResult.success("没有出库详情");
        }
        List<String> snList = taskDetailList.stream().map(TaskDetail::getSn).collect(Collectors.toList());;
        TaskDetail taskDetail = taskDetailList.get(0);
        AGVBean agvBean = new AGVBean();
        agvBean.setActualNumber(taskDetailList.size());
        agvBean.setTaskNo(taskHeader.getTaskIndex());
        agvBean.setOutSite(taskHeader.getPort());
        agvBean.setPalletCode(taskHeader.getContainerCode());
        agvBean.setMaterialCode(taskHeader.getMaterialCode());
        agvBean.setMaterialName(taskDetail.getMaterialName());
        agvBean.setSn(snList);
        agvBean.setThirdTaskNo(String.valueOf(taskHeader.getId()));
        agvBean.setStartWareHouseCode(warehouseCode);
        agvBean.setStartWareHouseAreaCode(String.valueOf(taskHeader.getArea()));
        String JsonParam = JSON.toJSONString(agvBean);
        System.out.println(JsonParam);
        String result = HttpUtils.bodypost("pushAGVTask", url, JsonParam);
        if(StringUtils.isEmpty(result)) {
            return AjaxResult.error(result);
        }
        AjaxResult ajaxResult = JSON.parseObject(result, AjaxResult.class);
        if(ajaxResult.getCode() != HttpConstant.OK) {
            return AjaxResult.error(ajaxResult.getMsg());
        }
        taskHeader.setAgv(0);
        taskHeaderService.updateById(taskHeader);
        return AjaxResult.success("发送出库托盘数据成功");
    }
}