wms / wms_guangxijianyi · Files

package com.huaheng.api.wcs.controller;

import com.alibaba.fastjson.JSONArray;

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.support.Convert;
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.domain.ContainerType;
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.domain.InventoryHeader;
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.apache.shiro.authz.annotation.RequiresPermissions;

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;

    @Resource

    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("manyEmptyIn",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("manyEmptyOut",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();

        String height = manyEmptyDomain.getHeight();

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

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

        roadWays = Arrays.asList(str);

        String value = configService.getKey(QuantityConstant.RULE_ALLOCATION);
        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();

        //空托盘优先入1，2巷道

        List<String> roadWayReault = allocationService.getRoadWays(area, roadWays, warehouseCode);

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

                roadWayReault, warehouseCode, containerCode, null,null);

        if (StringUtils.isEmpty(locationCode)) {

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

        return workTaskService.createManyEmptyIn(containerCode, locationCode, warehouseCode, 0);

    }

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

        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) {

            return AjaxResult.error("没有找到托盘, 托盘号:" + containerCode);

        }

        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("wcsCallEmptyOut",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);
    }

}