Merge branch 'master' of http://118.89.139.230:10101/r/powerIntelligenceSystem

whyclxw

7 天以前 326468e5ce8f9f69eb461f483cdd3a1c0575ad3c

Merge branch 'master' of http://118.89.139.230:10101/r/powerIntelligenceSystem

 src/main/java/com/whyc/mapper/WorkflowDeviceMapper.java

New file
@@ -0,0 +1,6 @@
package com.whyc.mapper;

import com.whyc.pojo.web_site.WorkflowDevice;

public interface WorkflowDeviceMapper extends CustomMapper<WorkflowDevice>{
}

 src/main/java/com/whyc/pojo/web_site/WorkflowDevice.java

New file
@@ -0,0 +1,35 @@
package com.whyc.pojo.web_site;

import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;

@ToString
@Data
@TableName(schema = "web_site",value ="tb_workflow_device")
@ApiModel("工单模块-现场故障模块-维修-入库-报废-出库的设备信息")
public class WorkflowDevice {

    private Integer id;
    @ApiModelProperty("器件名称")
    private String name;
    @ApiModelProperty("器件型号")
    private String model;
    @ApiModelProperty("器件版本")
    private String version;
    @ApiModelProperty("数量")
    private Integer quantity;
    @ApiModelProperty("未处理的数量.维修申请时需填入")
    private Integer quantityUnprocessed;
    @ApiModelProperty("品牌")
    private String brand;
    @ApiModelProperty("类型")
    private String type;
    @ApiModelProperty("供应商")
    private String supplier;
    @ApiModelProperty("工单流程主表id")
    private Integer mainId;

}

 src/main/java/com/whyc/pojo/web_site/WorkflowMain.java

@@ -54,11 +54,6 @@
    @ApiModelProperty("归档时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "Asia/Shanghai")
    private Date endTime;

    @ApiModelProperty("申请数量")
    private Integer quantity;
    @ApiModelProperty("未处理的数量.维修申请时需填入")
    private Integer quantityUnprocessed;
    /**任务等级*/
    @ApiModelProperty("任务等级")
    private Integer taskLevel;
@@ -104,15 +99,7 @@

    @TableField(exist = false)
    private List<WorkflowLink> linkList;
    public WorkflowMain(Integer id, Integer status, String endReason, Date endTime) {
        this.id = id;
        this.status = status;
        this.endReason = endReason;
        this.endTime = endTime;
    }

    public WorkflowMain() {

    }

    @TableField(exist = false)
    private List<WorkflowDevice> deviceList;
}

 src/main/java/com/whyc/service/WorkflowDeviceService.java

New file
@@ -0,0 +1,45 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.whyc.mapper.WorkflowDeviceMapper;
import com.whyc.pojo.web_site.WorkflowDevice;
import com.whyc.util.ActionUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class WorkflowDeviceService {

    @Autowired
    private WorkflowDeviceMapper mapper;

    public void addBatch(List<WorkflowDevice> deviceList) {
        mapper.insertBatchSomeColumn(deviceList);
    }

    public List<WorkflowDevice> getByMainId(Integer relatedId) {
        QueryWrapper<WorkflowDevice> query = Wrappers.query();
        query.eq("main_id",relatedId);
        return mapper.selectList(query);
    }

    public void setQuantityUnprocessedZero(Integer relatedId) {
        UpdateWrapper<WorkflowDevice> update = Wrappers.update();
        update.set("quantity_unprocessed",0).eq("main_id",relatedId);
        mapper.update((WorkflowDevice) ActionUtil.objeNull,update);
    }

    public void updateQuantityUnprocessedBatch(List<WorkflowDevice> deviceRelatedListInDB) {
        for (int i = 0; i < deviceRelatedListInDB.size(); i++) {
            WorkflowDevice deviceRelatedInDB = deviceRelatedListInDB.get(i);
            UpdateWrapper<WorkflowDevice> update = Wrappers.update();
            update.set("quantity_unprocessed",deviceRelatedInDB.getQuantityUnprocessed())
                    .eq("id",deviceRelatedInDB.getId());
            mapper.update((WorkflowDevice) ActionUtil.objeNull,update);
        }
    }
}

 src/main/java/com/whyc/service/WorkflowLinkService.java

@@ -6,6 +6,7 @@
import com.whyc.dto.Response;
import com.whyc.mapper.*;
import com.whyc.pojo.db_user.User;
import com.whyc.pojo.web_site.WorkflowDevice;
import com.whyc.pojo.web_site.WorkflowLink;
import com.whyc.pojo.web_site.WorkflowMain;
import com.whyc.util.CommonUtil;
@@ -27,6 +28,9 @@
    @Autowired
    @Lazy
    private WorkflowMainService mainService;

    @Autowired
    private WorkflowDeviceService deviceService;


    public void addBatch(List<WorkflowLink> links) {
@@ -63,11 +67,52 @@
                    mainService.updateById(mainInDB);
                    link.setDealAndClose(1);
                }
            }
            }break;
            //设备入库申请
            case 2:
            //设备报废申请
            case 3:{
                if(link.getStatus() == WorkflowEnum.LINK_STATUS_PASS.getValue().intValue()){
                    mainInDB.setStatus(WorkflowEnum.MAIN_STATUS_END_PASS.getValue());
                    mainInDB.setEndTime(now);
                    mainInDB.setEndReason(link.getDealReason());
                    mainService.updateById(mainInDB);
                }else if(link.getStatus() == WorkflowEnum.LINK_STATUS_REJECT.getValue().intValue()){
                    mainInDB.setStatus(WorkflowEnum.MAIN_STATUS_END_REJECT.getValue());
                    mainInDB.setEndReason(link.getDealRejectReason());
                    mainInDB.setEndTime(now);
                    //检查是否有关联工单.
                    // 如果有关联工单,关联工单状态重置为完结待处理,完成时间重置为空
                    if(mainInDB.getRelatedId() != null){
                        Integer relatedId = mainInDB.getRelatedId();
                        mainService.resetRepairStatus(relatedId);
                        //关联工单的设备附属表未处理数量也要回退,等于主表设备数量
                        List<WorkflowDevice> deviceRelatedListInDB = deviceService.getByMainId(mainInDB.getRelatedId());
                        List<WorkflowDevice> deviceListInDB = deviceService.getByMainId(mainInDB.getId());
                        for (int i = 0; i < deviceListInDB.size(); i++) {
                            WorkflowDevice deviceInDB = deviceListInDB.get(i);
                            for (int j = 0; j < deviceRelatedListInDB.size(); j++) {
                                WorkflowDevice deviceRelatedInDB = deviceRelatedListInDB.get(j);
                                if (deviceInDB.getName().equals(deviceRelatedInDB.getName())
                                        && deviceInDB.getModel().equals(deviceRelatedInDB.getModel())
                                        && deviceInDB.getVersion().equals(deviceRelatedInDB.getVersion())
                                        && deviceInDB.getBrand().equals(deviceRelatedInDB.getBrand())
                                        && deviceInDB.getType().equals(deviceRelatedInDB.getType())
                                        && deviceInDB.getSupplier().equals(deviceRelatedInDB.getSupplier())
                                ) {
                                    deviceRelatedInDB.setQuantityUnprocessed(deviceInDB.getQuantity());
                                    //关联工单当前设备附属的未处理数量回退完成,下一个
                                    break;
                                }
                            }
                        }
                        deviceService.updateQuantityUnprocessedBatch(deviceRelatedListInDB);
                    }
                    mainService.updateById(mainInDB);
                    link.setDealAndClose(1);
                }
            }break;
            case 4:{ //TODO 出库申请
                if(link.getStatus() == WorkflowEnum.LINK_STATUS_PASS.getValue().intValue()){
                    mainInDB.setStatus(WorkflowEnum.MAIN_STATUS_WAIT_FOR_DEALING.getValue());
                    mainService.updateById(mainInDB);
@@ -78,12 +123,14 @@
                    //检查是否有关联工单.如果有关联工单,关联工单状态重置为完结待处理,完成时间重置为空
                    if(mainInDB.getRelatedId() != null){
                        Integer relatedId = mainInDB.getRelatedId();
                        mainService.resetRepairStatus(relatedId,mainInDB.getQuantity());
                        //mainService.resetRepairStatus(relatedId,mainInDB.getQuantity());
                    }
                    mainService.updateById(mainInDB);
                    link.setDealAndClose(1);
                }
            }
            }break;
            default:
                break;

        }


 src/main/java/com/whyc/service/WorkflowMainService.java

@@ -11,6 +11,7 @@
import com.whyc.dto.Response;
import com.whyc.mapper.WorkflowMainMapper;
import com.whyc.pojo.db_user.User;
import com.whyc.pojo.web_site.WorkflowDevice;
import com.whyc.pojo.web_site.WorkflowLink;
import com.whyc.pojo.web_site.WorkflowMain;
import com.whyc.util.ActionUtil;
@@ -34,6 +35,9 @@

    @Autowired(required = false)
    private WorkflowLinkService linkService;

    @Autowired
    private WorkflowDeviceService deviceService;


    /**
@@ -235,6 +239,8 @@
    /**
     * 通用提交方法,提交给角色-角色层
     * 如果related_id不为空,则需要特殊处理. 证明会影响到关联单据
     *
     * 涉及到新的问题需要解决,现场故障后,设备维修申请 或 报废申请 是多个,并存入工单设备表中. 并不只是单纯的数量. TODO ?自动化处理怎么更新
     */

    @Transactional
@@ -242,10 +248,30 @@
        //1.提交到单据审批流程
        //如果存在关联单据id,首先校验提交的数量
        Date now = new Date();
        WorkflowMain mainRelated = getById(main.getRelatedId());
        List<WorkflowDevice>  deviceListRelatedInDB = deviceService.getByMainId(main.getRelatedId());
        List<WorkflowDevice> deviceList = main.getDeviceList();
        if(main.getRelatedId() != null) {
            if (main.getQuantity() > mainRelated.getQuantityUnprocessed()) {
                return new Response().setII(1, "入库数量不能大于维修申请关联单据的未处理数量");
            //遍历deviceList,如果deviceList内的对象的quantity值大于 deviceListRelatedInDB内对象列表中的对象所有字段相同的记录的quantityUnprocessed值,则返回错误
            for (int i = 0; i < deviceList.size(); i++) {
                WorkflowDevice device = deviceList.get(i);
                for (int j = 0; j < deviceListRelatedInDB.size(); j++) {
                    WorkflowDevice deviceInDB = deviceListRelatedInDB.get(j);
                    if (device.getName().equals(deviceInDB.getName())
                            && device.getModel().equals(deviceInDB.getModel())
                            && device.getVersion().equals(deviceInDB.getVersion())
                            && device.getBrand().equals(deviceInDB.getBrand())
                            && device.getType().equals(deviceInDB.getType())
                            && device.getSupplier().equals(deviceInDB.getSupplier())
                    ) {
                        if (device.getQuantity() > deviceInDB.getQuantityUnprocessed()) {
                            return new Response().setII(1, "入库数量不能大于维修申请关联单据的未处理数量");
                        }else{
                            //当前设备的校验结束,进入下一个设备校验
                            break;
                        }
                    }

                }
            }
        }
        //主表插入
@@ -268,9 +294,17 @@
        main.setStatus(mainStatus);
        main.setProcessStage(process.getStage());
        if(main.getType() == WorkflowTypeEnum.DEVICE_REPAIR.getType().intValue()){ //维修申请单,需填入
            main.setQuantityUnprocessed(main.getQuantity());
            for (int i = 0; i < deviceList.size(); i++) {
                deviceList.get(i).setQuantityUnprocessed(deviceList.get(i).getQuantity());
            }
        }
        add(main);
        //主表关联的物料插入
        for (WorkflowDevice device : deviceList) {
            device.setMainId(main.getId());
        }
        deviceService.addBatch(deviceList);

        //内存中去除已插入数据库的单号
        ServletContext application = ActionUtil.getApplication();
        List<String> orderIdList = (List<String>) application.getAttribute("orderIdList");
@@ -296,14 +330,25 @@
        linkService.add(link);

        //如果存在关联单据id,处理关联单据及自动生成新单据
        checkRelatedAndDone(main, now, mainRelated, user);
        checkRelatedAndDone(main, now, deviceListRelatedInDB, user);
        return new Response().setII(1,"提交完成");
    }

    private void checkRelatedAndDone(WorkflowMain main, Date now, WorkflowMain mainRelated, User user) {
    private void checkRelatedAndDone(WorkflowMain main, Date now, List<WorkflowDevice> deviceListRelatedInDB, User user) {
        if(main.getRelatedId() != null){
            //判断是申请的入库,还是报废.
            if (main.getQuantity() < mainRelated.getQuantityUnprocessed()){ //说明需要自动生成入库或者报废单据
            //申请的数量<关联单据的未处理数量,则说明有剩余. 需要自动生成对立工单
            List<WorkflowDevice> deviceList = main.getDeviceList();
            //计算deviceListn内quantity属性值的和
            int sumQuantity = 0;
            for (WorkflowDevice device : deviceList) {
                sumQuantity += device.getQuantity();
            }
            //计算deviceListRelatedInDBn内quantityUnprocessed属性值的和
            int sumQuantityUnprocessedInDB = 0;
            for (WorkflowDevice device : deviceListRelatedInDB) {
                sumQuantityUnprocessedInDB += device.getQuantityUnprocessed();
            }
            if (sumQuantity < sumQuantityUnprocessedInDB){ //说明需要自动生成入库或者报废单据
                //需要自动生成报废的申请
                WorkflowMain mainAuto = new WorkflowMain();
                WorkflowTypeEnum typeEnumAuto;
@@ -313,10 +358,52 @@
                mainAuto.setCreateUserId(user.getId());
                mainAuto.setCreateTime(now);
                mainAuto.setBeginTime(now);
                mainAuto.setQuantity(mainRelated.getQuantityUnprocessed()- main.getQuantity());
                mainAuto.setProcessStage(processAuto.getStage());
                mainAuto.setStatus(statusAuto);
                mainAuto.setRelatedId(main.getRelatedId());
                //整理主表的设备附表
                List<WorkflowDevice> deviceListAuto = new ArrayList<>();
                //遍历deviceListRelatedInDB,减去deviceList中申请的数量
                for (WorkflowDevice deviceInDB : deviceListRelatedInDB) {
                    boolean deviceExists = false;
                    for (WorkflowDevice device : deviceList) {
                        if (device.getName().equals(deviceInDB.getName())
                                && device.getModel().equals(deviceInDB.getModel())
                                && device.getVersion().equals(deviceInDB.getVersion())
                                && device.getBrand().equals(deviceInDB.getBrand())
                                && device.getType().equals(deviceInDB.getType())
                                && device.getSupplier().equals(deviceInDB.getSupplier())
                        ){
                            deviceExists = true;
                            if (deviceInDB.getQuantityUnprocessed()-device.getQuantity() > 0){
                                WorkflowDevice deviceAuto = new WorkflowDevice();
                                deviceAuto.setName(deviceInDB.getName());
                                deviceAuto.setModel(deviceInDB.getModel());
                                deviceAuto.setVersion(deviceInDB.getVersion());
                                deviceAuto.setQuantity(deviceInDB.getQuantityUnprocessed()-device.getQuantity());
                                deviceAuto.setBrand(deviceInDB.getBrand());
                                deviceAuto.setType(deviceInDB.getType());
                                deviceAuto.setSupplier(deviceInDB.getSupplier());

                                deviceListAuto.add(deviceAuto);
                            }else{
                                break;
                            }
                        }
                    }
                    if (!deviceExists){
                        WorkflowDevice deviceAuto = new WorkflowDevice();
                        deviceAuto.setName(deviceInDB.getName());
                        deviceAuto.setModel(deviceInDB.getModel());
                        deviceAuto.setVersion(deviceInDB.getVersion());
                        deviceAuto.setQuantity(deviceInDB.getQuantityUnprocessed());
                        deviceAuto.setBrand(deviceInDB.getBrand());
                        deviceAuto.setType(deviceInDB.getType());
                        deviceAuto.setSupplier(deviceInDB.getSupplier());

                        deviceListAuto.add(deviceAuto);
                    }
                }

                if(main.getType() == WorkflowTypeEnum.DEVICE_IN.getType().intValue()) { //申请的入库
                    mainAuto.setTaskDesc("提交了维修后的入库申请,系统自动生成剩余数量的报废申请");
@@ -330,6 +417,11 @@
                mainAuto.setTitle(titleAuto);
                mainAuto.setType(typeEnumAuto.getType());
                add(mainAuto);
                deviceListAuto.forEach(device -> {
                    device.setMainId(mainAuto.getId());
                });
                //插入主表的设备附表
                deviceService.addBatch(deviceListAuto);

                //自动节点生成
                WorkflowLink linkAuto = new WorkflowLink();
@@ -355,8 +447,9 @@
            }else{
                relatedMain.setEndReason("用户提交维修申请后的报废申请,维修流程结束");
            }
            relatedMain.setQuantityUnprocessed(0);
            updateById(relatedMain);
            //更新关联单据的设备剩余未处理数量为0
            deviceService.setQuantityUnprocessedZero(main.getRelatedId());
        }
    }

@@ -407,12 +500,11 @@
        mapper.update((WorkflowMain) ActionUtil.objeNull,update);
    }

    public void resetRepairStatus(Integer relatedId, Integer quantity) {
    public void resetRepairStatus(Integer relatedId) {
        UpdateWrapper<WorkflowMain> update = Wrappers.update();
        update.set("status",WorkflowEnum.MAIN_STATUS_WAIT_FOR_DEALING.getValue())
                .set("end_time",null)
                .set("end_reason",null)
                .set("quantity_unprocessed",quantity)
                .eq("id",relatedId);
        mapper.update((WorkflowMain) ActionUtil.objeNull,update);
    }