设备调拨、借用、归还流程审批调整

Lius

3 天以前 e334d8afd0a654aa845f720122b876807459b90d

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/service/impl/EamEquipmentTransferServiceImpl.java

@@ -88,8 +88,8 @@
            //没有选择设备，根据车间过滤设备
            queryWrapper.exists("select 1 from mdc_user_production t where t.user_id={0} and t.pro_id=e.org_id ", sysUser.getId());
        }
        //控制待提交状态的数据只能本人查看
        queryWrapper.and(i -> i.ne("wmo.transfer_status", EquipmentTransferStatusEnum.WAIT_SUBMIT).or().eq("wmo.report_user", sysUser.getUsername()));
//        控制待提交状态的数据只能本人查看
//        queryWrapper.and(i -> i.ne("wmo.transfer_status", EquipmentTransferStatusEnum.WAIT_SUBMIT).or().eq("wmo.report_user", sysUser.getUsername()));
        //查询条件过滤
        if (query != null) {
            if (StringUtils.isNotBlank(query.getEquipmentId())) {
@@ -144,7 +144,6 @@
            throw new JeecgBootException("当前设备属于此车间，不需要变动！");
        }
        request.setOldDepartId(equipment.getOrgId());
        request.setReportUser(sysUser.getUsername());
        return equipmentTransferMapper.insert(request) > 0;
    }

@@ -156,47 +155,43 @@
            throw new JeecgBootException("要提交的数据不存在，请刷新重试！");
        }
        if (!EquipmentTransferStatusEnum.WAIT_SUBMIT.name().equals(entity.getTransferStatus())) {
            throw new JeecgBootException("当前数据状态不允许编辑！");
            throw new JeecgBootException("该工单已进行过提交！");
        }
        //检查设备
        EamEquipment equipment = eamEquipmentService.getById(entity.getEquipmentId());
        if (equipment == null) {
            throw new JeecgBootException("设备不存在！");
            throw new JeecgBootException("设备不存在，提交失败！");
        }
        // 分配给使用单位领导
        List<UserSelector> userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(), equipment.getOrgId(), BusinessCodeConst.PCR0008);
        if (CollectionUtil.isEmpty(userSelectors)) {
            throw new JeecgBootException("设备未分配给单位领导，无法进入下级审批！");
        }
        List<String> usernames = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        if (sysUser == null) {
            throw new JeecgBootException("当前用户无法编辑转让记录！");
        if (sysUser == null || !BusinessCodeConst.PCR0004.equals(sysUser.getPost())) {
            throw new JeecgBootException("不是设备管理员，无法提交此工单！");
        }
        UpdateWrapper<EamEquipmentTransfer> updateWrapper = new UpdateWrapper<>();
        updateWrapper.set("transfer_status", EquipmentSealUpStatusEnum.WAIT_SUBMIT.name());
        updateWrapper.eq("id", id);
        updateWrapper.eq("report_user", sysUser.getUsername());
        boolean success = super.update(updateWrapper);
        if (success) {
            equipment.setAssetStatus(AssetStatusEnum.DEALT.name()); // 设备转让
            eamEquipmentService.updateById(equipment);
        }
        entity.setTransferTime(new Date());
        entity.setReportUser(sysUser.getUsername());
        entity.setTransferStatus(EquipmentTransferStatusEnum.WAIT_USE_LEADER_CHECK.name());
        //保存工单
        equipmentTransferMapper.updateById(entity);

        //启动审批流程
        flowCommonService.initActBusiness("工单号:" + entity.getCode() + ";设备编号: " + equipment.getEquipmentCode() + ";进行设备转让",
        flowCommonService.initActBusiness("工单号:" + entity.getCode() + ";设备编号: " + equipment.getEquipmentCode() + ";进行设备调拨",
                entity.getId(), "IEamEquipmentTransferService", "equipment_transfer", null);
        Map<String, Object> variables = new HashMap<>();
        variables.put("dataId", entity.getId());
        variables.put("organization", entity.getTransferReason());
        variables.put("comment", entity.getTransferReason());
        variables.put("proofreading", true);
        // 分配给设备管理员
        List<UserSelector> userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(), equipment.getOrgId(), BusinessCodeConst.PCR0004);
        if (CollectionUtil.isEmpty(userSelectors)) {
            throw new JeecgBootException("设备未分配给设备管理员，无法进入下级审批！");
        }
        List<String> usernames = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());

        variables.put("NextAssignee", usernames);
        Result result = flowDefinitionService.startProcessInstanceByKey("equipment_transfer", variables);
        if (result != null) {
            entity.setTransferTime(new Date());
            entity.setTransferStatus(EquipmentTransferStatusEnum.WAIT_CHECK.name());
            //保存工单
            equipmentTransferMapper.updateById(entity);
            equipment.setAssetStatus(AssetStatusEnum.DEALT.name()); // 设备调拨
            eamEquipmentService.updateById(equipment);
            return result.isSuccess();
        }
        return true;
@@ -215,7 +210,6 @@
        if (user == null || StrUtil.isBlank(user.getId())) {
            throw new JeecgBootException("未获取到登录用户，请重新登录后再试！");
        }
        request.setApprovalUser(user.getUsername());
        // 获取流程业务记录
        FlowMyBusiness flowMyBusiness = flowMyBusinessService.getFlowMyBusiness(request.getInstanceId());
        if (flowMyBusiness == null) {
@@ -236,50 +230,182 @@
            throw new JeecgBootException("设备不存在，请检查！");
        }

        EquipmentTransferStatusEnum status = EquipmentTransferStatusEnum.getInstance(entity.getTransferStatus());
        if (status == null) {
            return null;
        }
        //流程变量
        Map<String, Object> values = new HashMap<>();
        // 审批
        if (status == EquipmentTransferStatusEnum.WAIT_CHECK) {//执行完成
            values.put("dataId", entity.getId());
            values.put("organization", request.getApprovalComment());
            values.put("comment", request.getApprovalComment());
            values.put("approvalDealType", request.getApprovalDealType());
            request.setComment(request.getApprovalComment());
            entity.setApprovalUser(user.getUsername());// 审核人
            entity.setApprovalComment(request.getApprovalComment());// 审核意见
            entity.setApprovalTime(new Date());// 审核时间
            entity.setApprovalDealType(request.getApprovalDealType()); // 审批类型
            // 验证通过还是驳回
            if (request.getApprovalDealType().equals("1")) {
                //设置entity
                entity.setTransferStatus(EquipmentTransferStatusEnum.COMPLETE.name());
                List<String> userApprovalList = new ArrayList<>(Collections.singletonList(entity.getReportUser()));
                values.put("NextAssignee", userApprovalList);
            } else {
                //设置entity
                entity.setTransferStatus(EquipmentTransferStatusEnum.COMPLETE.name());
            }
            // 修改设备状态
            equipment.setAssetStatus(AssetStatusEnum.NORMAL.name());
            entity.setApprovalUser(user.getUsername());
            entity.setApprovalComment(request.getApprovalComment());
            entity.setApprovalTime(new Date());
            eamEquipmentService.updateById(equipment);
        }
        request.setValues(values);
        //设置流程变量
        setupProcessVariables(request, entity, user, equipment);

        // 完成流程任务
        Result result = flowTaskService.complete(request);
        if (!result.isSuccess()) {
            throw new JeecgBootException("审批失败，请刷新查看！");
        }

        // 根据任务完成结果更新工单状态
        updateOrderStatus(result, request, entity, user, equipment);

        //保存工单
        equipmentTransferMapper.updateById(entity);
        return entity;
    }

    /**
     * 设置工单信息
     *
     * @param result
     * @param request
     * @param entity
     * @param user
     */
    private void updateOrderStatus(Result result, EamEquipmentTransferRequest request, EamEquipmentTransfer entity, LoginUser user, EamEquipment equipment) {
        if (result.isSuccess()) {
            EquipmentTransferStatusEnum status = EquipmentTransferStatusEnum.getInstance(entity.getTransferStatus());
            switch (status) {
                case WAIT_USE_LEADER_CHECK:
                    // 使用单位领导审批结束
                    entity.setUseLeader(user.getUsername());
                    entity.setUseLeaderApprovalComment(request.getUseLeaderApprovalComment());
                    entity.setUseLeaderApprovalTime(new Date());
                    entity.setUseLeaderApprovalDealType(request.getUseLeaderApprovalDealType());
                    if (CommonConstant.APPROVED.equals(request.getUseLeaderApprovalDealType())) {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.WAIT_TRANSFER_LEADER_CHECK.name());
                    } else {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.REJECT.name());
                        equipment.setAssetStatus(AssetStatusEnum.NORMAL.name()); // 设备调拨
                        eamEquipmentService.updateById(equipment);
                    }
                    break;
                case WAIT_TRANSFER_LEADER_CHECK:
                    // 调入单位领导审批结束
                    entity.setTransferLeader(user.getUsername());
                    entity.setTransferLeaderApprovalComment(request.getTransferLeaderApprovalComment());
                    entity.setTransferLeaderApprovalTime(new Date());
                    entity.setTransferLeaderApprovalDealType(request.getTransferLeaderApprovalDealType());
                    if (CommonConstant.APPROVED.equals(request.getTransferLeaderApprovalDealType())) {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.WAIT_EXTERNAL_CONFIRM.name());
                    } else {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.REJECT.name());
                        equipment.setAssetStatus(AssetStatusEnum.NORMAL.name()); // 设备调拨
                        eamEquipmentService.updateById(equipment);
                    }
                    break;
                case WAIT_EXTERNAL_CONFIRM:
                    // 机动办确认结束
                    entity.setExternalConfirm(user.getUsername());
                    entity.setExternalConfirmTime(new Date());
                    entity.setCompanyLeaderCheck(request.getCompanyLeaderCheck());
                    if (CommonConstant.YN_1.equals(request.getCompanyLeaderCheck())) {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.WAIT_COMPANY_LEADER_CHECK.name());
                    } else {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.COMPLETE.name());
                        equipment.setOrgId(entity.getNewDepartId());
                        equipment.setAssetStatus(AssetStatusEnum.NORMAL.name()); // 设备调拨
                        eamEquipmentService.updateById(equipment);
                    }
                    break;
                case WAIT_COMPANY_LEADER_CHECK:
                    // 公司领导审批结束
                    entity.setCompanyLeader(user.getUsername());
                    entity.setCompanyLeaderApprovalTime(new Date());
                    entity.setCompanyLeaderApprovalComment(request.getCompanyLeaderApprovalComment());
                    entity.setCompanyLeaderApprovalDealType(request.getCompanyLeaderApprovalDealType());
                    if (CommonConstant.APPROVED.equals(request.getCompanyLeaderApprovalDealType())) {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.COMPLETE.name());
                        equipment.setOrgId(entity.getNewDepartId());
                    } else {
                        entity.setTransferStatus(EquipmentTransferStatusEnum.REJECT.name());
                    }
                    equipment.setAssetStatus(AssetStatusEnum.NORMAL.name()); // 设备调拨
                    eamEquipmentService.updateById(equipment);
                    break;
            }
        }
    }

    /**
     * 设置流程变量
     *
     * @param request
     * @param entity
     * @param user
     * @param equipment
     */
    private void setupProcessVariables(EamEquipmentTransferRequest request, EamEquipmentTransfer entity, LoginUser user, EamEquipment equipment) {
        Map<String, Object> values = new HashMap<>();
        List<UserSelector> userSelectors;
        List<String> userApprovalList;
        EquipmentTransferStatusEnum status = EquipmentTransferStatusEnum.getInstance(entity.getTransferStatus());
        switch (status) {
            case WAIT_USE_LEADER_CHECK:
                // 使用单位领导审批结束
                values.put("dataId", entity.getId());
                values.put("organization", request.getUseLeaderApprovalComment());
                values.put("comment", request.getUseLeaderApprovalComment());
                if (CommonConstant.APPROVED.equals(request.getUseLeaderApprovalDealType())) {
                    // 通过
                    values.put("approvalDealType", request.getUseLeaderApprovalDealType());
                    // 获取下一步审批人
                    userSelectors = sysUserService.selectOperatorList(entity.getNewDepartId(), BusinessCodeConst.PCR0008);
                    if (CollectionUtil.isEmpty(userSelectors)) {
                        throw new JeecgBootException("未分配调入单位领导，无法进入下级审批！");
                    }
                    userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                    values.put("NextAssignee", userApprovalList);
                } else {
                    // 驳回
                    values.put("approvalDealType", request.getUseLeaderApprovalDealType());
                }
                request.setComment("使用单位领导审批结束");
                break;
            case WAIT_TRANSFER_LEADER_CHECK:
                // 调入单位领导审批结束
                values.put("dataId", entity.getId());
                values.put("organization", request.getTransferLeaderApprovalComment());
                values.put("comment", request.getTransferLeaderApprovalComment());
                if (CommonConstant.APPROVED.equals(request.getTransferLeaderApprovalDealType())) {
                    // 通过
                    values.put("approvalDealType", request.getTransferLeaderApprovalDealType());
                    // 获取下一步审批人
                    userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(), equipment.getOrgId(), BusinessCodeConst.PCR0006);
                    if (CollectionUtil.isEmpty(userSelectors)) {
                        throw new JeecgBootException("设备未分配给机动办，无法进入下级审批！");
                    }
                    userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                    values.put("NextAssignee", userApprovalList);
                } else {
                    // 驳回
                    values.put("approvalDealType", request.getTransferLeaderApprovalDealType());
                }
                request.setComment("调入单位领导审批结束");
                break;
            case WAIT_EXTERNAL_CONFIRM:
                // 机动办确认结束
                values.put("dataId", entity.getId());
                values.put("organization", "机动办确认结束");
                values.put("comment", "机动办确认结束");
                if (CommonConstant.YN_1.equals(request.getCompanyLeaderCheck())) {
                    // 需要
                    values.put("confirmation", request.getCompanyLeaderCheck());
                    // 流程转到公司领导审批
                    // 获取下一步审批人
                    userSelectors = sysUserService.selectOperatorList(BusinessCodeConst.PCR0009);
                    if (CollectionUtil.isEmpty(userSelectors)) {
                        throw new JeecgBootException("设备未分配给公司领导，无法进入下级审批！");
                    }
                    userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                    values.put("NextAssignee", userApprovalList);
                } else {
                    values.put("confirmation", request.getCompanyLeaderCheck());
                }
                request.setComment("机动办确认结束");
                break;
            case WAIT_COMPANY_LEADER_CHECK:
                // 公司领导审批结束
                values.put("dataId", entity.getId());
                values.put("organization", request.getCompanyLeaderApprovalComment());
                values.put("comment", request.getCompanyLeaderApprovalComment());
                request.setComment("公司领导审批结束");
                break;
        }
        request.setValues(values);
    }

    @Override
@@ -331,7 +457,10 @@

    @Override
    public List<String> flowCandidateUsernamesOfTask(String taskNameId, Map<String, Object> values) {
        return null;
        //业务是否干预流程，业务干预，流程干预，指定人员进行处理
        //获取下一步处理人
        Object object = values.get("NextAssignee");
        return (List<String>) object;
    }

    /**