wms / wms_xianyangming · Files

package com.huaheng.api.wcs.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.wcs.domain.ManyEmptyDomain;

import com.huaheng.api.wcs.domain.WcsTask;
import com.huaheng.api.wcs.service.taskAssignService.TaskAssignService;

import com.huaheng.api.wcs.service.warecellAllocation.LocationAllocationService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;

import com.huaheng.framework.aspectj.lang.annotation.ApiLogger;

import com.huaheng.framework.aspectj.lang.annotation.Log;
import com.huaheng.framework.aspectj.lang.constant.BusinessType;
import com.huaheng.framework.web.controller.BaseController;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.service.ConfigService;

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.containerType.service.ContainerTypeService;

import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.location.service.LocationService;

import com.huaheng.pc.config.locationHigh.domain.LocationHigh;
import com.huaheng.pc.config.locationHigh.service.LocationHighService;
import com.huaheng.pc.config.locationType.domain.LocationType;
import com.huaheng.pc.config.locationType.service.LocationTypeService;
import com.huaheng.pc.config.zone.domain.Zone;
import com.huaheng.pc.config.zone.service.ZoneService;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;

import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;

import com.huaheng.pc.task.taskHeader.service.WorkTaskService;

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

import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

import java.util.ArrayList;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/API/WMS/v2")
public class EmptyContainerController extends BaseController {

    @Resource
    private WorkTaskService workTaskService;
    @Resource
    private LocationAllocationService allocationService;
    @Resource
    private ConfigService configService;
    @Resource
    private ZoneService zoneService;
    @Resource

    private LocationService locationService;
    @Resource

    private LocationTypeService locationTypeService;
    @Resource
    private LocationHighService locationHighService;
    @Resource
    private ContainerService containerService;

    @Resource
    private ContainerTypeService containerTypeService;

    @Autowired
    private AddressService addressService;
    @Resource
    private TaskHeaderService taskHeaderService;

    @Resource
    private TaskAssignService taskAssignService;

    @Resource
    private InventoryHeaderService inventoryHeaderService;

    /**

     * 生成空托盘组入库任务

     *

     * @return
     */
    @PostMapping("/manyEmptyIn")
    @Log(title = "任务-任务管理", operating = "生成空托盘组入库任务", action = BusinessType.INSERT)
    @ResponseBody
    @Transactional

    @ApiLogger(apiName = "manyEmptyIn", from = "ROBOT")

    public AjaxResult manyEmptyIn(@RequestBody ManyEmptyDomain manyEmptyDomain) {

        AjaxResult ajaxResult = handleMultiProcess(new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = innerManyEmptyIn(manyEmptyDomain);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    /**
     * 生成空托盘组出库任务

     *

     * @return
     */
    @PostMapping("/manyEmptyOut")
    @Log(title = "任务-任务管理", operating = "生成空托盘组出库任务", action = BusinessType.INSERT)
    @ResponseBody
    @Transactional

    @ApiLogger(apiName = "manyEmptyOut", from = "ROBOT")

    public AjaxResult manyEmptyOut(@RequestBody ManyEmptyDomain manyEmptyDomain) {
        AjaxResult ajaxResult = handleMultiProcess(new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = innerManyEmptyOut(manyEmptyDomain);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    private AjaxResult innerManyEmptyIn(@RequestBody ManyEmptyDomain manyEmptyDomain) {

        if (manyEmptyDomain == null) {

            throw new ServiceException("空托盘组参数不对！");
        }
        String containerCode = manyEmptyDomain.getContainerCode();

        String warehouseCode = manyEmptyDomain.getWarehouseCode();

        String area = manyEmptyDomain.getArea();
        String roadWay = manyEmptyDomain.getRoadWay();

        List<String> roadWays = new ArrayList<>();

        String[] str = roadWay.split(",");

        roadWays = Arrays.asList(str);

        String value = configService.getKey(QuantityConstant.RULE_ALLOCATION);
        String height = manyEmptyDomain.getHeight();
        if (StringUtils.isEmpty(value)) {
            return AjaxResult.error("未绑定定位规则");
        }
        int allocationRule = Integer.parseInt(value);
        LambdaQueryWrapper<Zone> zoneLambdaQueryWrapper = Wrappers.lambdaQuery();
        zoneLambdaQueryWrapper.eq(Zone::getArea, area);
        Zone zone = zoneService.getOne(zoneLambdaQueryWrapper);

        if (zone == null) {

            return AjaxResult.error("分配库位时，没有找到库区");
        }

        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode)
                .eq(TaskHeader::getWarehouseCode, warehouseCode)
                .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);

        if (taskHeader != null) {

            return AjaxResult.success("已经生成空托盘组任务");
        }

        //查询满足条件的库位类型
        LambdaQueryWrapper<LocationType> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(LocationType::getZoneCode, zone.getCode())
                .eq(LocationType::getWarehouseCode, warehouseCode);
        List<LocationType> locationTypeList = locationTypeService.list(lambdaQueryWrapper);

        if (locationTypeList == null) {

            return AjaxResult.error("分配库位时，没有找到库位类型");
        }
        List<String> locationTypeCodeList = locationTypeList.stream().
                map(t -> t.getCode()).collect(Collectors.toList());

        int highHeight = Float.valueOf(height).intValue();

        LambdaQueryWrapper<LocationHigh> locationHighLambdaQueryWrapper = Wrappers.lambdaQuery();

        locationHighLambdaQueryWrapper.eq(LocationHigh::getHighLevel, highHeight)

                .in(LocationHigh::getLocationTypeCode, locationTypeCodeList);
        LocationHigh locationHigh = locationHighService.getOne(locationHighLambdaQueryWrapper);
        int high = locationHigh.getHigh();

        String locationCode = allocationService.allocation(allocationRule, locationTypeCodeList, area,

                roadWays, warehouseCode, containerCode, null, null);

        if (locationCode == null) {

            return AjaxResult.error("分配库位时，没有找到库位");
        }
        return workTaskService.createManyEmptyIn(containerCode, locationCode, warehouseCode);
    }

    private AjaxResult innerManyEmptyOut(ManyEmptyDomain manyEmptyDomain) {

        if (manyEmptyDomain == null) {

            throw new ServiceException("空托盘组参数不对！");
        }

        String warehouseCode = manyEmptyDomain.getWarehouseCode();

        String area = manyEmptyDomain.getArea();

        String port = manyEmptyDomain.getPort();

        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_MANY)
                .eq(Container::getWarehouseCode, warehouseCode);
        List<Container> containerList = containerService.list(containerLambdaQueryWrapper);
        List<Container> removeContainerList = new ArrayList<>();

        if (containerList != null && containerList.size() > 0) {
            for (Container container : containerList) {

                String locationCode = container.getLocationCode();
                Location location = locationService.getLocationByCode(locationCode, warehouseCode);

                if (!location.getArea().equals(area)) {

                    removeContainerList.add(container);
                }
            }
        }
        LambdaQueryWrapper<Zone> zoneLambdaQueryWrapper = Wrappers.lambdaQuery();
        zoneLambdaQueryWrapper.eq(Zone::getArea, area);
        Zone zone = zoneService.getOne(zoneLambdaQueryWrapper);
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                .eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_MANY_EMPTYSHIPMENT)

                .eq(TaskHeader::getPort, port)

                .eq(TaskHeader::getZoneCode, zone.getCode());
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);

        if (taskHeader != null) {

            WcsTask wcsTask = new WcsTask();
            wcsTask.setTaskType(taskHeader.getTaskType());
            wcsTask.setTaskNo(String.valueOf(taskHeader.getId()));
            wcsTask.setContainerCode(taskHeader.getContainerCode());
            wcsTask.setWarehouseCode(warehouseCode);
            wcsTask.setFromLocationCode(taskHeader.getFromLocation());
            wcsTask.setPlatform(QuantityConstant.PLATFORM_WMS);
            wcsTask.setPriority(1000);
            wcsTask.setTaskStatus(taskHeader.getStatus());

            wcsTask.setToPort(port);

            wcsTask = taskAssignService.switchTaskTypeToWcs(wcsTask);
            return AjaxResult.success(wcsTask);
        }
        containerList.removeAll(removeContainerList);

        if (!(containerList != null && containerList.size() > 0)) {

            return AjaxResult.error("没有找到合适的空托盘组！");

        }

        String containerCode = containerList.get(0).getCode();

        Container container = containerService.getContainerByCode(containerCode, warehouseCode);

        if (container == null) {

            throw new ServiceException("没有找到托盘“");
        }

        return workTaskService.createManyEmptyOut(containerCode, warehouseCode, port);

    }

    /**
     * 生成空托出库任务

     *

     * @return
     */
    @PostMapping("/wcsCallEmptyOut")
    @Log(title = "任务-任务管理", operating = "生成空托出库任务", action = BusinessType.INSERT)
    @ResponseBody

    @ApiLogger(apiName = "生成空托出库任务", from = "WCS")

    public AjaxResult wcsCallEmptyOut(@RequestBody ManyEmptyDomain manyEmptyDomain) {
        AjaxResult ajaxResult = handleMultiProcess(new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = innerWcsCallEmptyOut(manyEmptyDomain);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    private AjaxResult innerWcsCallEmptyOut(ManyEmptyDomain manyEmptyDomain) {
        String warehouseCode = manyEmptyDomain.getWarehouseCode();
        String area = manyEmptyDomain.getArea();
        String port = manyEmptyDomain.getPort();

        if (warehouseCode == null) {

            return AjaxResult.error("warehouseCode 不能为空");
        }

        if (area == null) {

            return AjaxResult.error("area 不能为空");
        }

        if (port == null) {

            return AjaxResult.error("port 不能为空");
        }
        LambdaQueryWrapper<Zone> zoneLambdaQueryWrapper = Wrappers.lambdaQuery();
        zoneLambdaQueryWrapper.eq(Zone::getWarehouseCode, warehouseCode)
                .eq(Zone::getArea, area);
        Zone zone = zoneService.getOne(zoneLambdaQueryWrapper);

        if (zone == null) {

            return AjaxResult.error("area不正确，没有找到对应区域");
        }
        String zoneCode = zone.getCode();
        List<Location> list = containerService.getEmptyContainerInLocation(zoneCode,

                "", "", warehouseCode);
        if (list == null || list.size() <= 0) {

            return AjaxResult.error("没有找到空托盘");
        }
        Location location = list.get(0);
        String containerCode = location.getContainerCode();
        String locationCode = location.getCode();
        return inventoryHeaderService.createEmptyOut(containerCode, locationCode, port, warehouseCode);
    }

}