ANTAI-WLTMS-API/src/main/java/com/steerinfo/dil/controller/BackgroundProcessingController.java

package com.steerinfo.dil.controller;


import com.steerinfo.dil.mapper.BackgroundProcessingMapper;
import com.steerinfo.dil.mapper.OmstruckOrderMapper;
import com.steerinfo.dil.mapper.UniversalMapper;
import com.steerinfo.dil.service.impl.BackgroundProcessingServiceImpl;
import com.steerinfo.dil.util.BaseRESTfulController;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.framework.controller.RESTfulResult;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/*
 * 后台处理程序
 */

@RestController
@RequestMapping("${api.version}/bp")
public class BackgroundProcessingController extends BaseRESTfulController {

    @Autowired
    private BackgroundProcessingMapper backgroundProcessingMapper;

    @Autowired
    private BackgroundProcessingServiceImpl backgroundProcessingService;

    @Autowired
    private OmstruckOrderMapper omstruckOrderMapper;

    @Autowired
    private UniversalMapper universalMapper;


    @ApiOperation(value = "关闭一车多趟方法")
    @PostMapping("/closePurOrderMoreTrips")
    public RESTfulResult closePurOrderMoreTrips(String purchaseOrderNo, String deleteNoReceiveOrder) {
        int i = backgroundProcessingMapper.closePurOrderMoreTrips(purchaseOrderNo);
        if("yes".equals(deleteNoReceiveOrder)){
            //查询该采购订单下所有未接收的运输订单（5,6,7,8,17,18)
            ArrayList<Integer> orderIdList = backgroundProcessingMapper.getAllPurOrder(purchaseOrderNo);
            if(orderIdList != null && orderIdList.size() != 0){
                backgroundProcessingMapper.deleteOrders(orderIdList); //物理删除
                backgroundProcessingMapper.deleteOrderMaterials(orderIdList);//物理删除物资子表
                backgroundProcessingMapper.batchByOrderIdForTotalDelete(orderIdList);//总实绩表
            }
        }
        if(i != 1){
            return failed("关闭失败！没有此采购订单");
        }
        return success("关闭成功");
    }

    @ApiOperation(value = "更改所属厂区方法")
    @PostMapping("/updatePurOrgId")
    public RESTfulResult updatePurOrgId(@RequestBody(required = false) Map<String, Object> map){
        return success(backgroundProcessingService.updatePurOrgId(map));
    }

    @ApiOperation(value = "删除没用的表实绩 ")
    @PostMapping("/deleteErrorResult")
    public RESTfulResult deleteErrorResult(String orderNumber){
        return success(backgroundProcessingService.deleteErrorResult(orderNumber));
    }

    @ApiOperation(value = "手动允许放行-OK字段")
    @PostMapping("/allowEnfactory")
    public RESTfulResult allowEnfactory(String orderNumber){
        return success(backgroundProcessingMapper.allowEnfactory(orderNumber));
    }

    @ApiOperation(value = "获取cid和车牌号的关系")
    @PostMapping("/bindCidCapacityNo")
    public RESTfulResult bindCidCapacityNo(String cid,
                                           String capacityNo){
        if(cid == null || capacityNo == null || "null".equals(cid) || "null".equals(capacityNo)){
            return success(0);
        }
        int i = backgroundProcessingService.bindCidCapacityNo(cid,capacityNo);
        return success(i);
    }

    @ApiOperation(value = "更新运输订单canwork状态")
    @PostMapping("updateOrderCanWork")
    public RESTfulResult updateOrderCanWork(String orderNumber){
        if(orderNumber != null){
            int i = backgroundProcessingMapper.updateOrderCanWork(orderNumber);
            return success(i);
        }
        return success(0);
    }

    @ApiOperation(value = "更新运输订单状态接口")
    @PostMapping("updateOrderStatus")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult updateOrderStatus(@RequestBody(required = false) Map<String,Object> map) throws Exception{
        if (map.get("orderNumber") != null) {
            if (DataChange.dataToBigDecimal(map.get("orderStatus")).intValue() != 2) {
                int i = backgroundProcessingMapper.updateOrderStatus(map);
                if(i > 1){
                    throw new Exception("该订单号有多个运单，不允许修改，请去数据库手动修改订单状态！");
                }
                return success(i);
            }
        }
        return failed(0);
    }

    @ApiOperation(value = "内转/采购新增上传金蝶表")
    @PostMapping("insertToUploadEas")
    public RESTfulResult insertToUploadEas(@RequestBody(required = false) Map<String,Object> map){
        try {
            Map<String,Object> purchaseOrder = (Map<String, Object>) map.get("purchaseOrder");
            List<Map<String,Object>> list= (List<Map<String, Object>>) map.get("list");
            for(Map<String,Object> item:list){
                item.put("purchaseOrderNo",purchaseOrder.get("purchaseOrderNo"));
                backgroundProcessingMapper.insertNotUpload(item);
            }
        }catch (NullPointerException e){
            e.printStackTrace();
            return failed("缺乏参数！");
        }catch (Exception e){
            e.printStackTrace();
            return failed("未知异常！");
        }
        return success("修改成功，稍后会自动上传金蝶！");
    }

    @ApiOperation(value = "重置钢材打印数量")
    @PostMapping("resetPrintNumber")
    public RESTfulResult resetPrintNumber(@RequestBody(required = false) Map<String,Object> map){
        return success(backgroundProcessingMapper.resetPrintNumber(map));
    }

    @ApiOperation(value = "删除进厂和排队")
    @PostMapping("clearEnAndQue")
    public RESTfulResult clearEnAndQue(@RequestBody(required = false) Map<String,Object> map){
        try {
            Map<String,Object> mesMap = backgroundProcessingMapper.getDetailsForEnAndQue(map);
            if(mesMap == null){
                return failed("没有符合条件的运单，请确认该运单是否已有净重！");
            }
            //清空进厂信息
            backgroundProcessingMapper.clearEnDetails(mesMap);
            //删除排队
            int materialMesCount = omstruckOrderMapper.getMaterialNumByOrderId(mesMap);
            if (materialMesCount == 1) {
                //如果是单拼,则删除排队实绩
                omstruckOrderMapper.deleteQueueList(DataChange.dataToBigDecimal(mesMap.get("capacityId")));
                omstruckOrderMapper.deleteQueueResult(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
            }else{
                omstruckOrderMapper.deleteQueueSpellList(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
                omstruckOrderMapper.deleteQueueResult(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
            }
            //将总实绩里面的部分信息去掉,并改路段顺序号为null
            omstruckOrderMapper.updateTotalResultNull(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
            universalMapper.updateLineSqe(mesMap);
        } catch (Exception e) {
            e.printStackTrace();
            return failed("未知异常!",e.getMessage());
        }
        return success("修改成功！");
    }
}