wms / hhwms · Files

package com.huaheng.api.acs.service;

import com.alibaba.fastjson.JSON;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.common.utils.http.HttpUtils;
import com.huaheng.common.utils.security.ShiroUtils;

import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.pc.config.address.domain.Address;
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.LocationPosition;

import com.huaheng.pc.config.points.domain.Points;
import com.huaheng.pc.config.points.service.PointsService;
import com.huaheng.pc.config.pointsRecord.domain.PointsRecord;
import com.huaheng.pc.config.pointsRecord.service.PointsRecordService;

import com.huaheng.pc.monitor.agvcarinfo.domain.StateInfoUploadModel;
import com.huaheng.pc.monitor.agvcarinfo.service.AgvStateInfoService;

import com.huaheng.pc.system.user.domain.User;
import com.huaheng.pc.system.user.service.IUserService;
import com.huaheng.pc.system.user.service.UserServiceImpl;
import com.huaheng.pc.task.agvTask.domain.AgvTask;
import com.huaheng.pc.task.agvTask.service.IAgvTaskService;

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.TaskHeaderAgvService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;

import io.swagger.models.auth.In;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

/**
 * @ClassName AcsServiceImpl
 * @Description TODO
 * @Author Administrator
 * @Date 2019/12/2615:38
 */
@Service
public class AcsServiceImpl implements AcsService {

    private static final Logger logger = LoggerFactory.getLogger(AcsServiceImpl.class);
    @Autowired
    private AddressService addressService;
    @Autowired
    private PointsService pointsService;
    @Autowired
    private IUserService userService;
    @Autowired
    private TaskHeaderService taskHeaderService;
    @Autowired
    private PointsRecordService pointsRecordService;
    @Autowired
    private IAgvTaskService agvTaskService;
    @Autowired
    private TaskHeaderAgvService taskHeaderAgvService;

    @Autowired
    private TaskDetailService taskDetailService;

    @Autowired
    private ContainerService containerService;

    @Autowired
    private AgvStateInfoService agvStateInfoService;

    final String interactionId = "6EAB7794-CFD7-449A-A754-FFDB98CE44C7";

    @Override
    public AjaxResult StateInfoUpload(StateInfoUploadModel model) {

        try {

            if(StringUtils.isEmpty(model.getWarehouseCode())){
                return AjaxResult.error("请填写warehouseCode字段");
            }

            String json = JSON.toJSONString(model);
            logger.info("信息上传改变货架状态1：{}",json);

            if(model.getState().equals("2")) {
                Points points = new Points();
                points.setGoodsShelfNo(model.getShelfNo());

                points.setWarehouseCode(model.getWarehouseCode());

//                points.setIsLocked(1);

                points=pointsService.selectEntity(points);
                if(points!=null) {

                    logger.info("信息上传改变货架状态2：{}",json);
                    points.setIsLocked(2);
                    boolean result = pointsService.updateById(points);
                    if (!result) {
                        throw new ServiceException("小车回传状态时修改货架状态失败");
                    }
                    agvStateInfoService.insertModel(model);
                }
            }
        }catch (Exception e){
            return AjaxResult.error("没有数据");
        }
        return AjaxResult.success("收到");

    }

    @Override

    public AjaxResult TaskConfirm(AgvTask model) {

//        model.setWarehouseCode(ShiroUtils.getWarehouseCode());
        if(StringUtils.isEmpty(model.getWarehouseCode())){
            return AjaxResult.error("没有填写warehouseCode");
        }

        boolean result=agvTaskService.save(model);
        if(!result){
            throw new ServiceException("数据插入失败");
        }

        String shelfNo = model.getShelfNo().substring(0, 5);

        String warehouseCode = ShiroUtils.getWarehouseCode();
        Points points=new Points();

//        points.setWarehouseCode(warehouseCode);

        points.setGoodsShelfNo(shelfNo);
        points=pointsService.selectEntity(points);
        if(points==null){
            throw new ServiceException("没有对应的货架");
        }
        if(model.getTaskType().equals("pick") && model.getState().equals("1")){
            points.setIsLocked(0);
            boolean rt=pointsService.updateById(points);
            if(!rt){
                throw new ServiceException("删除AGV出库任务后修改货架状态失败");
            }
        }
        //回传任务为putway时，查找到改货架中物料为agv的任务，并完成任务。

        return AjaxResult.success(model);

    }

    private String getUrl(){
        Address address =new Address();
        address.setParam("AGV");
        address.setWarehouseCode(ShiroUtils.getWarehouseCode());
        String url=addressService.selectEntity(address).getUrl();
        return url;
    }
    /**
     * AGV 任务取消
     */
    @Override

    @Transactional(rollbackFor = Exception.class)

    public AjaxResult taskCancel(String message)
    {
        Map<String, Object> map = new HashMap<>();
        map.put("interactionId", interactionId);
        map.put("reason", message);
        String JsonParam = JSON.toJSONString(map);
        String url= this.getUrl()+"TaskCancel";

        String result = HttpUtils.bodypost(url, JsonParam,"KS0001");

        AjaxResult ajaxResult = JSON.parseObject(result, AjaxResult.class);
        return ajaxResult;
    }
    /**
     * AGV 旋转方向
     */
    @Override
    public AjaxResult TurnOriention(String carNo,String orientation)
    {
        Map<String, String> map = new HashMap<>();
        map.put("carNo", carNo);
        map.put("orientation", orientation);
        String JsonParam = JSON.toJSONString(map);
        String url= this.getUrl()+"TurnOriention";

        String result = HttpUtils.bodypost(url, JsonParam,"KS0001");

        AjaxResult ajaxResult = JSON.parseObject(result, AjaxResult.class);
        return ajaxResult;
    }
    //手动叫车
    @Transactional
    @Override
    public AjaxResult ManualCalling(String station,String shelfNo){
        AgvTask model = new AgvTask();
        model.setTaskHeaderId(666);
        model.setTaskDetailId(666);
        model.setWarehouseCode(ShiroUtils.getWarehouseCode());
        model.setCompanyId(ShiroUtils.getCompanyIdList().get(0));
        model.setCompanyCode(ShiroUtils.getCompanyCodeList().get(0));
        model.setTaskType("pick");
        model.setShelfNo(shelfNo);
        model.setStation(station);
        model.setStatus(20);
        Points points=new Points();
        points.setWarehouseCode(ShiroUtils.getWarehouseCode());
        points.setGoodsShelfNo(shelfNo);
        AjaxResult ajaxResult=new AjaxResult();
        points=pointsService.selectEntity(points);
        if(points==null){
            throw new ServiceException("没有此货架");
        }
        if(points.getIsLocked()!=1 && points.getIsLocked()!=2) {
            model.setFromLocationNo("");
            model.setToLocationNo("");
            model.setOrientation("A");
            ajaxResult = this.TaskAssign(model);
            if (!ajaxResult.hasErr()) {
                points.setIsLocked(1);
                points.setStation(station);
                points.setOIntX(points.getIntX());
                points.setOIntY(points.getIntY());
                pointsService.updateById(points);
            }
        }else {
            throw new ServiceException("该货架已出库");
        }
        return ajaxResult;
    }
    /**
     * AGV 任务下发
     */

    public AjaxResult TaskAssign(AgvTask model)
    {
        model.setInteractionId(interactionId);
        User user =  userService.selectUserByLoginName(ShiroUtils.getLoginName());
        if(user == null){
            model.setPlatform("wms");
        }else {
            model.setPlatform(user.getUserName());
        }
        String url = this.getUrl()+"TaskAssign";
        String JsonParam = JSON.toJSONString(model);
        logger.info("任务下发：{}",JsonParam);

        String result = HttpUtils.bodypost(url, JsonParam,model.getWarehouseCode());

        if(StringUtils.isEmpty(result)){
            throw new ServiceException("ACS接口地址错误或服务器连接不到或返回为空");
        }
        AjaxResult ajaxResult = JSON.parseObject(result, AjaxResult.class);
        return ajaxResult;
    }
    /**
     * 设置agv下发任务的实体
     *
     */
    @Transactional
    @Override
    public AjaxResult TaskModel(String station,Integer id){
        AjaxResult ajaxResult=new AjaxResult();
        AgvTask model=new AgvTask();

        //通过id查找任务
        TaskHeader task= taskHeaderService.getById(id);
        if(task==null){
            return AjaxResult.error("任务不存在");
        }

        String containerCode=task.getContainerCode();

//        String code=containerCode.substring(0,4);
        Container container=containerService.getContainerByCode(containerCode,task.getWarehouseCode());

        Points points=new Points();
        points.setWarehouseCode(ShiroUtils.getWarehouseCode());

        points.setGoodsShelfNo(container.getGoodsShelfNo());

        points=pointsService.selectEntity(points);

        //任务下发实体
        model.setTaskHeaderId(task.getId());
        model.setTaskDetailId(task.getId());
        model.setTaskType("pick");
        model.setStation(station);
        model.setWarehouseId(task.getWarehouseId());
        model.setWarehouseCode(task.getWarehouseCode());
        model.setCompanyId(task.getCompanyId());
        model.setCompanyCode(task.getCompanyCode());
        model.setStatus(10);
        if(containerCode.substring(5,6).equals("1")) {
            model.setOrientation("A");
        }else {
            model.setOrientation("C");
        }
        //判断货架是否处于1阶段，1阶段为pick阶段。
        if (points == null) {
            throw new ServiceException("货架不存在！");
        }

        //如果其他人有这个货架的任务已下发，则提示该货架有任务
        List<TaskHeader> agvUncompletedTasks = taskHeaderService.list(
                new LambdaQueryWrapper<TaskHeader>()
                        .eq(TaskHeader::getGoodsShelfNo, points.getGoodsShelfNo())
                        .ne(TaskHeader::getCreatedBy, task.getCreatedBy())
                        .eq(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_RELEASE)
        );
        if (agvUncompletedTasks!=null&&agvUncompletedTasks.size()>0) {
            throw new ServiceException("货架存在其他任务，请稍后下发！");
        }

        Integer[] ids=null;

        if(points.getGoodsShelfNo()!=null){
            List<TaskHeader> agvUncompletedTask = taskHeaderService.list(
                    new LambdaQueryWrapper<TaskHeader>()
                            .eq(TaskHeader::getGoodsShelfNo, points.getGoodsShelfNo())

                            .eq(TaskHeader::getCreatedBy, task.getCreatedBy())

                            .ge(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_BUILD)

                            .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
            );

            /*if(!agvUncompletedTask.isEmpty()){

                return AjaxResult.error(""+points.getGoodsShelfNo()+"有在执行任务");

            }*/

            List<Integer> codeList = agvUncompletedTask.stream().map(t -> t.getId()).collect(Collectors.toList());

            ids=codeList.toArray(new Integer[codeList.size()]);

        }

//        String ids=id.toString();

        //islocked  1出库中2在站台3在库内
        if((points.getIsLocked()==0 || points.getIsLocked()==3) || !station.equals(points.getStation())){

            model.setShelfNo(points.getGoodsShelfNo());
            model.setFromLocationNo("");
            model.setToLocationNo("");

            model.setDate(new Date());

            ajaxResult=this.TaskAssign(model);
//            ajaxResult=AjaxResult.success();

            if(!ajaxResult.hasErr()){
                //修改points表，设为出库状态,修改出库前位置
                points.setIsLocked(1);
                points.setOIntX(points.getIntX());
                points.setOIntY(points.getIntY());
                points.setStation(station);
                pointsService.updateById(points);
                if(!agvTaskService.save(model)){
                    throw new ServiceException("agv任务下发失败");
                }

                if(taskHeaderAgvService.sendTaskToAGV(ids,station).hasErr()){

                    throw new ServiceException("执行任务失败");
                }

                PointsRecord pointsRecord = new PointsRecord();
                pointsRecord.setCode(points.getGoodsShelfNo());
                pointsRecord.setStation(station);
                pointsRecord.setCreated(new Date());
                pointsRecord.setCreatedby(ShiroUtils.getLoginName());
                pointsRecordService.save(pointsRecord);
            }else{
                return ajaxResult;
            }
        }else{

            if(taskHeaderAgvService.sendTaskToAGV(ids,station).hasErr()){

                throw new ServiceException("执行任务失败");
            }
            return AjaxResult.success("任务执行成功，该货架已出库");
        }
        return  ajaxResult;
    }

    /**
     * agv  putway任务下发
     *
     */
    @Override
    @Transactional
    public AjaxResult TaskAssigns(Integer taskId,String shlfNo,String station,String row,String line)
    {
        //查找下发任务
        int result=0;
        String warehouseCode=ShiroUtils.getWarehouseCode();
        AgvTask agvTask=new AgvTask();
        if(taskId==null){
            agvTask.setTaskHeaderId(666);
            agvTask.setTaskDetailId(666);
        }else {
            TaskDetail task = taskDetailService.getById(taskId);
            agvTask.setTaskHeaderId(task.getId());
            agvTask.setTaskDetailId(task.getId());
            agvTask.setCompanyId(task.getCompanyId());
            agvTask.setCompanyCode(task.getCompanyCode());
        }
        agvTask.setWarehouseCode(ShiroUtils.getWarehouseCode());
        agvTask.setTaskType("putway");
        AjaxResult ajaxResult = new AjaxResult();
        //查找需要回去的对应的货架

        String containCode=shlfNo.substring(0, 5);

        Points points=new Points();
        points.setWarehouseCode(warehouseCode);
        points.setGoodsShelfNo(containCode);
        points.setIsLocked(2);

        points=pointsService.selectEntityV(points);

        if(points!=null) {
            AgvTask model = new AgvTask();
            model.setTaskHeaderId(agvTask.getTaskHeaderId());
            model.setTaskDetailId(agvTask.getTaskDetailId());
            model.setTaskType("putway");
            model.setShelfNo(points.getGoodsShelfNo());
            model.setStation(station);
            model.setFromLocationNo("");

            //给出目的位置
            //找出已出库的货架
            Points point=new Points();
            point.setWarehouseCode(warehouseCode);
            point.setGoodsShelfNo(points.getGoodsShelfNo());
//            Integer number=pointsService.selectRanking(point);
//            if(number == null){
//                return AjaxResult.error("该货架不处于在站台状态，无法回库");
//            }
//
//            List<Points> pointsList = pointsService.selectILPointsList();
//            point = pointsList.get(number-1);

            point=pointsService.selectEntity(point);


            //如果查找到的货架和回库任务的货架相同，就不做操作
            if(point.getOIntX().equals(points.getIntX()) && point.getOIntY().equals(points.getIntY())){
                model.setToLocationNo("");
            }else {
                //如果不同，则目的位置为该货架的oIntX，oIntY
                model.setToLocationNo(point.getOIntX() + "," + point.getOIntY());
            }

            model.setOrientation("A");

            //#####################

            ajaxResult = this.TaskAssign(model);
            String jsons = JSON.toJSONString(ajaxResult);
            logger.info("回库回传信息：{}",jsons);
            String shelfNo=points.getGoodsShelfNo().substring(1, 5);
            LocationPosition lps=new LocationPosition();
            lps.setWarehouseCode(warehouseCode);
            lps.setIntX(point.getOIntX());
            lps.setIntY(point.getOIntY());

            LocationPosition lpss=new LocationPosition();
            lpss.setWarehouseCode(warehouseCode);
            lpss.setIntX(points.getIntX());
            lpss.setIntY(points.getIntY());


            if (!ajaxResult.hasErr()) {

                //回去位置与货架位置不一样时
                if(!lps.getIntX().equals(points.getIntX()) || !lps.getIntY().equals(points.getIntY()) ) {

                    //位置不同时，修改回库货架的x，y值
                    points.setIntX(lps.getIntX());
                    points.setIntY(lps.getIntY());
                    pointsService.updateById(points);

                    //位置不同，货架编号不同时，修改回去位置的货架的o属性x，y值
                    if(!point.getGoodsShelfNo().equals(points.getGoodsShelfNo())) {
                        point.setOIntX(points.getOIntX());
                        point.setOIntY(points.getOIntY());
                        pointsService.updateById(point);
                    }
                }

                points.setIsLocked(3);
                points.setNum(points.getNum()+1);
                points.setStation("");

                pointsService.updateById(points);
                String json = JSON.toJSONString(points);
                logger.info("回库后货架信息：{}",json);
//                model.setCompanyId(agvTask.getCompanyId());
//                model.setCompanyCode(agvTask.getCompanyCode());
//                model.setWarehouseId(agvTask.getWarehouseId());
//                model.setWarehouseCode(agvTask.getWarehouseCode());
//                if (agvTaskMapper.insertModel(model) < 1) {
//                    throw new ServiceException("agv任务下发失败");
//                }
            }
        }else {
            throw new ServiceException("该货架已建立回库任务");
        }
        return ajaxResult;
    }

}