wms / sanyizhongka · Files

package com.huaheng.pc.task.taskHeader.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.huaheng.api.general.domain.ReturnTask;
import com.huaheng.api.general.service.IReturnTaskService;
import com.huaheng.api.general.service.ReturnService;
import com.huaheng.api.wcs.domain.WcsTask;
import com.huaheng.api.wcs.service.taskCancel.TaskCancelService;
import com.huaheng.common.constant.HttpConstant;
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.OkHttpUtils;
import com.huaheng.common.utils.restful.RestUtil;
import com.huaheng.common.utils.security.ShiroUtils;
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.page.PageDomain;
import com.huaheng.framework.web.page.TableDataInfo;
import com.huaheng.framework.web.page.TableSupport;
import com.huaheng.framework.web.service.ConfigService;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.configValue.domain.ConfigValue;
import com.huaheng.pc.config.configValue.service.ConfigValueService;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.warehouse.domain.Warehouse;
import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetail;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.domain.WcsLocationReturn;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
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.mapper.TaskHeaderMapper;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import com.huaheng.pc.task.taskHeader.service.WorkTaskService;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.session.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;


@Controller
@RequestMapping("/task/taskHeader")


public class TaskHeaderController extends BaseController {

    @Autowired
    private AddressService addressService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private WorkTaskService workTaskService;
    @Resource
    private TaskCancelService taskCancelService;
    @Resource
    private ConfigService configService;

    @Resource
    private ReturnService returnService;
    @Resource
    IReturnTaskService returnTaskService;

    private String prefix = "task/taskHeader";

    @RequiresPermissions("task:taskHeader:view")
    @GetMapping()
    public String taskHeader(HttpServletRequest request, ModelMap mmap) {
        String InternalTaskType= request.getParameter("InternalTaskType");
        mmap.put("InternalTaskType",InternalTaskType);
        return prefix + "/taskHeader";
    }

    /**
     * 查询任务列表
     */
    @RequiresPermissions("task:taskHeader:list")
    @Log(title = "任务-上架任务", operating = "查看任务列表", action = BusinessType.GRANT)
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(TaskHeader taskHeader,@ApiParam(name="InternalTaskType",value="类型") Integer InternalTaskType,
                              @ApiParam(name="createdBegin",value="类型") String createdBegin,@ApiParam(name="createdEnd",value="类型") String createdEnd) {
        LambdaQueryWrapper<TaskHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(TaskHeader::getWarehouseCode,ShiroUtils.getWarehouseCode())
                .eq(StringUtils.isNotNull(InternalTaskType),TaskHeader::getInternalTaskType,InternalTaskType)
                .eq(StringUtils.isNotNull(taskHeader.getId()),TaskHeader::getId,taskHeader.getId())
                .eq(StringUtils.isNotEmpty(taskHeader.getContainerCode()),TaskHeader::getContainerCode,taskHeader.getContainerCode())
                .eq(StringUtils.isNotEmpty(taskHeader.getToLocation()),TaskHeader::getToLocation,taskHeader.getToLocation())
                .eq(StringUtils.isNotEmpty(taskHeader.getZoneCode()),TaskHeader::getZoneCode,taskHeader.getZoneCode())
                .eq(StringUtils.isNotNull(taskHeader.getPriority()),TaskHeader::getPriority,taskHeader.getPriority())
                .gt(StringUtils.isNotEmpty(createdBegin),TaskHeader::getCreated,createdBegin)
                .lt(StringUtils.isNotEmpty(createdEnd),TaskHeader::getCreated,createdEnd)
                .eq(StringUtils.isNotNull(taskHeader.getStatus()),TaskHeader::getStatus,taskHeader.getStatus())
                .orderByAsc(TaskHeader::getStatus)
                .orderByDesc(TaskHeader::getId);

        PageDomain pageDomain = TableSupport.buildPageRequest();
        Integer pageNum = pageDomain.getPageNum();
        Integer pageSize = pageDomain.getPageSize();
        /**
         * 使用分页查询
         */
        if (StringUtils.isNotNull(pageNum) && StringUtils.isNotNull(pageSize)){
            Page<TaskHeader> page = new Page<>(pageNum, pageSize);
            IPage<TaskHeader> iPage = taskHeaderService.page(page, lambdaQueryWrapper);
            List<TaskHeader> iPages = iPage.getRecords();
            return getMpDataTable(iPages, iPage.getTotal());
        } else {
            List<TaskHeader> list = taskHeaderService.list(lambdaQueryWrapper);
            return getDataTable(list);
        }
    }

    /**
     * 下发任务
     */
    @RequiresPermissions("task:taskHeader:execute")
    @Log(title = "任务-任务管理", operating = "下发立库任务", action = BusinessType.UPDATE)
    @PostMapping( "/execute")
    @ResponseBody
    public AjaxResult execute(String taskId)
    {
        if (StringUtils.isEmpty(taskId)){
            return AjaxResult.error("taskId不能为空");
        }
        AjaxResult ajaxResult = taskHeaderService.sendTaskToWcs(Convert.toIntArray(taskId));
        return ajaxResult;
    }

    /**
     * 修改
     */
    @GetMapping("/edit/{id}")
    public String edit(@PathVariable("id") Integer id, ModelMap mmap) {
        TaskHeader taskHeader = taskHeaderService.getById(id);
        mmap.put("taskHeader", taskHeader);
        return prefix + "/edit";
    }

    /**
     * 修改保存
     */
    @ApiOperation(value="修改优先级", notes="修改优先级", httpMethod = "POST")
    @Log(title = "任务-修改优先级 ",operating = "修改优先级 ", action = BusinessType.UPDATE)
    @PostMapping("/edit")
    @ResponseBody
    public AjaxResult editSave(TaskHeader taskHeader) {
        TaskHeader receiptHeader1 = taskHeaderService.getById(taskHeader.getId());
        if (taskHeader.getPriority() >100 || taskHeader.getPriority()<=0){
            return AjaxResult.error("优先级只能在1和100之间");
        }
        if (receiptHeader1.getStatus() ==100){
            return AjaxResult.error("任务已经完成，不用修改优先级");
        }
        //WCS
        String zoneCode = receiptHeader1.getZoneCode();
        String area="";
        if (zoneCode.equals("A")) {
            area="1";
        } else if (zoneCode.equals("B")) {
            area="2";
        }else{
            area="3";
        }
        String url = addressService.selectAddress(QuantityConstant.ADDRESS_WCS_TASK_PRIORITY_CHANGE,"CS0001",area);
        WcsTask wcsTask = new WcsTask();
        wcsTask.setTaskNo(String.valueOf(taskHeader.getId()));
        wcsTask.setPriority(receiptHeader1.getPriority());
        String jsonParam = JSON.toJSONString(wcsTask);
        System.out.println("Request JSON: " + jsonParam);

        ResponseEntity<JSONObject> result = RestUtil.request_post(url, "CS0001", jsonParam);
        if (result != null && result.getBody() != null) {
            String code = result.getBody().getString("code");
            String msg = result.getBody().getString("msg");
            if (Integer.parseInt(code) != HttpConstant.OK) {
                throw new ServiceException("wcs回复错误"+msg);
            }
        } else {
            throw new ServiceException("接口地址错误或返回为空");
        }

        return toAjax(taskHeaderService.updateById(taskHeader));
    }


    /**
     * 修改最大优先级
     */
    @ApiOperation(value = "最大优先级", notes = "最大优先级", httpMethod = "POST")
    @PostMapping("/prioritymax")
    @ResponseBody
    public AjaxResult editBatchSave (String ids) {
        return toAjax(taskHeaderService.prioritymax(ids));
    }
    /**
     * 修改最小优先级
     */
    @ApiOperation(value = "最小优先级", notes = "最小优先级", httpMethod = "POST")
    @PostMapping("/prioritymin")
    @ResponseBody
    public AjaxResult prioritymin (String ids) {
        return  toAjax( taskHeaderService.prioritymin(ids));
    }




    /**
     * 完成任务
     */
    @RequiresPermissions("task:taskHeader:complete")
    @Log(title = "任务-任务管理", operating = "PC完成立库任务", action = BusinessType.UPDATE)
    @PostMapping( "/completeTaskByWMS")
    @ResponseBody
    public AjaxResult completeTaskByWMS(String taskId){
        if (StringUtils.isEmpty(taskId)){
            return AjaxResult.error("taskId不能为空");
        }
        return taskHeaderService.completeTaskByWMS(Convert.toIntArray(taskId), null);
    }

    /**
     * 回传任务
     */
    @RequiresPermissions("task:taskHeader:Echo")
    @Log(title = "任务-任务管理", operating = "回传集团WMS任务", action = BusinessType.UPDATE)
    @PostMapping( "/Echo")
    @ResponseBody
    public AjaxResult Echo(String taskId){
        if (StringUtils.isEmpty(taskId)){
            return AjaxResult.error("taskId不能为空");
        }

        TaskHeader taskHeader = taskHeaderService.getById(taskId);
        int taskType = taskHeader.getTaskType();
        if(taskType == QuantityConstant.TASK_TYPE_EMPTYRECEIPT) {
            ReturnTask returnTaskDomain = new ReturnTask();
            returnTaskDomain.setReqID(taskHeader.getUserDef2());
            returnTaskDomain.setTaskNo(taskHeader.getUserDef3());
            returnTaskDomain.setTaskStatus(2);//1代表开始 出库任务开始
            returnTaskDomain.setFrequency(1);
            returnTaskDomain.setSendBack(0);  //0代表没回传
            returnTaskDomain.setContainerCode(taskHeader.getContainerCode());
            returnTaskService.save(returnTaskDomain);
        } else {
            int s = returnService.PostBack(taskHeader);//回传任务完成
        }

        return AjaxResult.success("成功");
    }






    /**
     * 出库查看页面
     */
    @GetMapping("/taskOut/{id}")
    public String taskOut(@PathVariable("id") String id, ModelMap modelMap){
        modelMap.put("id", id);
        return prefix+"/taskOut";
    }

    /**
     * 出库查看任务
     * @param ids
     * @param port
     * @return
     */
    @PostMapping("/taskOut")
    @Log(title = "任务-任务管理", operating = "出库查看任务", action = BusinessType.INSERT)
    @ResponseBody
    public AjaxResult taskOut(String ids,String port){
        if(StringUtils.isEmpty(ids) || StringUtils.isEmpty(port)){
            throw new ServiceException("库存头和出库口不能为空！");
        }
        TaskHeader taskHeader = taskHeaderService.getById(ids);
        if (taskHeader.getStatus()>=QuantityConstant.TASK_STATUS_RUNNING)
        {
            return AjaxResult.error("已经执行的不能改了");
        }
        taskHeader.setPort(port);


        Map<String, String> map = new HashMap<String, String>();
        map.put("taskId",taskHeader.getId()+"");
        map.put("port",taskHeader.getPort());

        String jsonParam = JSON.toJSONString(map);

        ResponseEntity<JSONObject> result = RestUtil.request_post("http://127.0.0.1:8887/wms/task/taskHeader/backWare", taskHeader.getWarehouseCode(), jsonParam);



        return AjaxResult.success("更换成功");
      }


    /**
     * 删除立库任务
     */
    @RequiresPermissions("task:taskHeader:remove")
    @Log(title = "任务-任务管理", operating = "删除立库任务", action = BusinessType.DELETE)
    @PostMapping( "/removePost")
    @ResponseBody
    @Transactional
    public AjaxResult removePost(String ids)
    {
        //取消任务
        TaskHeader header = taskHeaderService.getById(ids);
        header.setStatus(QuantityConstant.TASK_STATUS_BUILD);
        taskHeaderService.updateById(header);
        String value1 = configService.getKey(QuantityConstant.RULE_CONNECT_WCS);
        int connectWCS = Integer.parseInt(value1);
        if(connectWCS == QuantityConstant.RULE_WCS_CONNECT) {
            Integer[] idList = Convert.toIntArray(String.valueOf(header.getId()));
            for (int id : idList) {
                TaskHeader taskHeader = taskHeaderService.getById(id);
                if(taskHeader.getStatus().intValue()  <= QuantityConstant.TASK_STATUS_BUILD) {
                    continue;
                }
                AjaxResult ajaxResult = taskCancelService.TaskCance(id);
                if (ajaxResult.hasErr()) {
                    return ajaxResult;
                }
            }
        }
        ReturnTask returnTaskDomain = new ReturnTask();
        returnTaskDomain.setReqID(header.getUserDef2());
        returnTaskDomain.setTaskNo(header.getUserDef3());
        returnTaskDomain.setTaskStatus(2);//1代表开始 出库任务开始
        returnTaskDomain.setSendBack(0);  //0代表没回传
        returnTaskDomain.setFrequency(1);
        returnTaskDomain.setContainerCode(header.getContainerCode());
        returnTaskService.save(returnTaskDomain);
        //回传完成的
        return taskHeaderService.cancelTask(Convert.toIntArray(String.valueOf(header.getId())));
    }


    /**
     * 删除立库任务
     */
    @RequiresPermissions("task:taskHeader:remove")
    @Log(title = "任务-任务管理", operating = "删除立库任务", action = BusinessType.DELETE)
    @PostMapping( "/remove")
    @ResponseBody
    public AjaxResult remove(String ids)
    {
        if (StringUtils.isEmpty(ids)) {
            return AjaxResult.error("taskId不能为空");
        }
        String value = configService.getKey(QuantityConstant.RULE_CONNECT_WCS);
        int connectWCS = Integer.parseInt(value);
        if(connectWCS == QuantityConstant.RULE_WCS_CONNECT) {
            Integer[] idList = Convert.toIntArray(ids);
            for (int id : idList) {
                TaskHeader taskHeader = taskHeaderService.getById(id);
                if(taskHeader.getStatus().intValue()  <= QuantityConstant.TASK_STATUS_BUILD) {
                    continue;
                }
                AjaxResult ajaxResult = taskCancelService.TaskCance(id);
                if (ajaxResult.hasErr()) {
                    return ajaxResult;
                }
            }
        }

        return taskHeaderService.cancelTask(Convert.toIntArray(ids));
    }

    /**
     * 自动分配任务库位
     * WCS
     * @param taskId
     * @param high
     * @return
     */
    @PostMapping("/setLocationCode")
    @ResponseBody
    public AjaxResult setLocationCode( Integer taskId, Integer high){
        if (taskId == null){
            return AjaxResult.error("任务id不能为空");
        }
        if (high == null){
            return AjaxResult.error("高库位标识不能为空");
        }
        return taskHeaderService.setLocationCode(taskId, high);
    }

    @Log(title = "库位监控-出库查看", operating = "出库查看", action = BusinessType.GRANT)
    @PostMapping("/checkLocationCode")
    @ResponseBody
    public AjaxResult checkLocationCode (String locationCode) {
        if (StringUtils.isEmpty(locationCode)) {
            return AjaxResult.error("库位不能为空！");
        }
        List<String> list = new ArrayList<>();
        list.add(locationCode);
        return workTaskService.createCheckOutTask(list, null);
    }

    /**
     * 选择出库口
     */
    @GetMapping("/chooseStation/{taskId}")
    public String chooseStation(@PathVariable("taskId")String taskId, ModelMap mmap) {
        TaskHeader taskHeader = taskHeaderService.getById(taskId);
        String containerCode = taskHeader.getContainerCode();
        mmap.put("containerCode", containerCode);
        mmap.put("id", taskId);
        int taskType = taskHeader.getTaskType().intValue();
        if(taskType == QuantityConstant.TASK_TYPE_WHOLESHIPMENT ||
                taskType == QuantityConstant.TASK_TYPE_EMPTYSHIPMENT)  {
            mmap.put("type", QuantityConstant.STATION_OUT);
        } else if(taskType == QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT ||
                taskType == QuantityConstant.TASK_TYPE_SORTINGSHIPMENT ||
                taskType == QuantityConstant.TASK_TYPE_VIEW ||
                taskType == QuantityConstant.TASK_TYPE_CYCLECOUNT) {
            mmap.put("type", QuantityConstant.STATION_PICK);
        } else {
            throw new ServiceException("任务类型不需要选站台");
        }
        return prefix + "/chooseStation";
    }

    @Log(title = "设置站台", operating = "设置站台", action = BusinessType.GRANT)
    @PostMapping("/setStation")
    @ResponseBody
    public AjaxResult setStation (TaskHeader taskHeader){
        Integer taskiId = taskHeader.getId();
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getId, taskiId);
        TaskHeader taskHeader1 = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        taskHeader1.setPort(taskHeader.getPort());
        taskHeaderService.update(taskHeader1, taskHeaderLambdaQueryWrapper);
        return execute(String.valueOf(taskiId));
    }
}