diff --git a/src/main/java/neatlogic/module/process/operationauth/handler/AutomaticOperateHandler.java b/src/main/java/neatlogic/module/process/operationauth/handler/AutomaticOperateHandler.java index 4888db7101595e0e67a87037a139ba3fd4b73be1..87f4073dd8aa9ce281239806a3651d9989f3db7e 100644 --- a/src/main/java/neatlogic/module/process/operationauth/handler/AutomaticOperateHandler.java +++ b/src/main/java/neatlogic/module/process/operationauth/handler/AutomaticOperateHandler.java @@ -1,14 +1,15 @@ package neatlogic.module.process.operationauth.handler; import com.alibaba.fastjson.JSONObject; -import neatlogic.framework.process.operationauth.core.IOperationType; +import neatlogic.framework.process.constvalue.ProcessStepHandlerType; import neatlogic.framework.process.constvalue.ProcessTaskStepOperationType; import neatlogic.framework.process.dto.ProcessTaskStepVo; import neatlogic.framework.process.dto.ProcessTaskVo; import neatlogic.framework.process.exception.operationauth.ProcessTaskAutomaticHandlerNotEnableOperateException; import neatlogic.framework.process.exception.operationauth.ProcessTaskPermissionDeniedException; +import neatlogic.framework.process.operationauth.core.IOperationType; import neatlogic.framework.process.operationauth.core.OperationAuthHandlerBase; -import neatlogic.framework.process.operationauth.core.OperationAuthHandlerType; +import neatlogic.framework.process.operationauth.core.PredicateResult; import neatlogic.framework.process.operationauth.core.TernaryPredicate; import org.springframework.stereotype.Component; @@ -31,7 +32,7 @@ public class AutomaticOperateHandler extends OperationAuthHandlerBase { //1.提示“自动处理节点不支持'撤回'操作”； operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskAutomaticHandlerNotEnableOperateException(operationType)); - return false; + return PredicateResult.DENY; }); operationBiPredicateMap.put(ProcessTaskStepOperationType.STEP_WORK, (processTaskVo, processTaskStepVo, userUuid, operationTypePermissionDeniedExceptionMap, extraParam) -> { @@ -40,7 +41,7 @@ public class AutomaticOperateHandler extends OperationAuthHandlerBase { //1.提示“自动处理节点不支持'处理'操作”； operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskAutomaticHandlerNotEnableOperateException(operationType)); - return false; + return PredicateResult.DENY; }); operationBiPredicateMap.put(ProcessTaskStepOperationType.STEP_COMMENT, (processTaskVo, processTaskStepVo, userUuid, operationTypePermissionDeniedExceptionMap, extraParam) -> { @@ -49,13 +50,13 @@ public class AutomaticOperateHandler extends OperationAuthHandlerBase { //1.提示“自动处理节点不支持'回复'操作”； operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskAutomaticHandlerNotEnableOperateException(operationType)); - return false; + return PredicateResult.DENY; }); } @Override public String getHandler() { - return OperationAuthHandlerType.AUTOMATIC.getValue(); + return ProcessStepHandlerType.AUTOMATIC.getHandler(); } @Override diff --git a/src/main/java/neatlogic/module/process/operationauth/handler/OmnipotentOperateHandler.java b/src/main/java/neatlogic/module/process/operationauth/handler/OmnipotentOperateHandler.java index cc977a82d66eded6195a12cd29b1df9d2cf14c01..41536cda3f155df8083026c661f068ee0b986baa 100644 --- a/src/main/java/neatlogic/module/process/operationauth/handler/OmnipotentOperateHandler.java +++ b/src/main/java/neatlogic/module/process/operationauth/handler/OmnipotentOperateHandler.java @@ -1,12 +1,12 @@ package neatlogic.module.process.operationauth.handler; import com.alibaba.fastjson.JSONObject; -import neatlogic.framework.process.operationauth.core.IOperationType; +import neatlogic.framework.process.constvalue.ProcessStepHandlerType; import neatlogic.framework.process.dto.ProcessTaskStepVo; import neatlogic.framework.process.dto.ProcessTaskVo; import neatlogic.framework.process.exception.operationauth.ProcessTaskPermissionDeniedException; +import neatlogic.framework.process.operationauth.core.IOperationType; import neatlogic.framework.process.operationauth.core.OperationAuthHandlerBase; -import neatlogic.framework.process.operationauth.core.OperationAuthHandlerType; import neatlogic.framework.process.operationauth.core.TernaryPredicate; import org.springframework.stereotype.Component; @@ -27,7 +27,7 @@ public class OmnipotentOperateHandler extends OperationAuthHandlerBase { @Override public String getHandler() { - return OperationAuthHandlerType.OMNIPOTENT.getValue(); + return ProcessStepHandlerType.OMNIPOTENT.getHandler(); } @Override diff --git a/src/main/java/neatlogic/module/process/operationauth/handler/StepOperateHandler.java b/src/main/java/neatlogic/module/process/operationauth/handler/StepOperateHandler.java index b84f7859968fd917551df8c3a41f15e80e9e47b2..0f71ab2ba1fc9cdbd5ed1b691f09099f18ea51f0 100644 --- a/src/main/java/neatlogic/module/process/operationauth/handler/StepOperateHandler.java +++ b/src/main/java/neatlogic/module/process/operationauth/handler/StepOperateHandler.java @@ -13,10 +13,7 @@ import neatlogic.framework.process.dto.ProcessTaskStepUserVo; import neatlogic.framework.process.dto.ProcessTaskStepVo; import neatlogic.framework.process.dto.ProcessTaskVo; import neatlogic.framework.process.exception.operationauth.*; -import neatlogic.framework.process.operationauth.core.IOperationType; -import neatlogic.framework.process.operationauth.core.OperationAuthHandlerBase; -import neatlogic.framework.process.operationauth.core.OperationAuthHandlerType; -import neatlogic.framework.process.operationauth.core.TernaryPredicate; +import neatlogic.framework.process.operationauth.core.*; import neatlogic.module.process.service.ProcessTaskService; import org.apache.commons.collections4.CollectionUtils; import org.springframework.stereotype.Component; @@ -60,7 +57,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (!AuthActionChecker.checkByUserUuid(userUuid, PROCESSTASK_MODIFY.class.getSimpleName()) && !SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； @@ -68,34 +65,34 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //4.依次判断当前用户是否是工单上报人、代报人、处理人、待处理人，如果都不是，则执行第5步； if (userUuid.equals(processTaskVo.getOwner())) { - return true; + return PredicateResult.ACCEPT; } else if (userUuid.equals(processTaskVo.getReporter())) { - return true; + return PredicateResult.ACCEPT; } else if (checkIsProcessTaskStepUser(processTaskStepVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } else if (checkIsWorker(processTaskStepVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } // 条件节点没有地方设置查看权限，默认所有人都有查看权限 if (Objects.equals(processTaskStepVo.getHandler(), ProcessStepHandlerType.CONDITION.getHandler())) { - return true; + return PredicateResult.ACCEPT; } //5.判断当前用户是否有当前步骤“查看节点信息”操作权限，如果没有，则提示“您的'查看节点信息'操作未获得授权”； boolean flag = checkOperationAuthIsConfigured(processTaskVo, processTaskStepVo, operationType, userUuid); if (flag) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; }); /** * 步骤转交权限 @@ -110,7 +107,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -128,14 +125,14 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； // 步骤状态为已激活的才能转交 if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -146,20 +143,20 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //12.判断当前用户是否有当前步骤“转交”操作权限，如果没有，则提示“您的'转交'操作未获得授权”； boolean flag = checkOperationAuthIsConfigured(processTaskVo, processTaskStepVo, operationType, userUuid); if (flag) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; }); /** * 步骤接受（抢单）权限 @@ -173,7 +170,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -191,13 +188,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； //10.判断步骤状态是否是“已挂起”，如果是，则提示“步骤已挂起”； @@ -206,7 +203,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } if (ProcessTaskStepStatus.SUCCEED.getValue().equals(processTaskStepVo.getStatus()) || ProcessTaskStepStatus.RUNNING.getValue().equals(processTaskStepVo.getStatus()) || ProcessTaskStepStatus.PENDING.getValue().equals(processTaskStepVo.getStatus())) { List userList = processTaskStepVo.getUserList(); @@ -221,14 +218,14 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } } else { UserVo userVo = userMapper.getUserBaseInfoByUuid(processTaskStepUserVo.getUserUuid()); if (userVo != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepHandledByOthersException(userVo.getUserId(), userVo.getUserName())); - return false; + return PredicateResult.DENY; } } } @@ -237,21 +234,21 @@ public class StepOperateHandler extends OperationAuthHandlerBase { } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否是当前步骤的待处理人，如果不是，则提示“您不是步骤待处理人”； if (!checkIsWorker(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotWorkerException()); - return false; + return PredicateResult.DENY; } //14.判断当前用户是否是当前步骤的处理人，如果是，则提示“您已经是步骤处理人”； if (checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepMajorUserException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 步骤开始权限 @@ -265,7 +262,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -283,13 +280,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -302,20 +299,20 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； // 有主处理人时是start if (checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; }); /** * 步骤流转权限 @@ -329,7 +326,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； //3.判断工单状态是否是“已取消”，如果是，则提示“工单已取消”； @@ -345,13 +342,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //7.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //8.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //9.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -364,25 +361,25 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //12.判断当前步骤是否有下一步骤，如果没有，则提示“该步骤没有下一步骤”； if (!checkNextStepIsExistsByProcessTaskStepIdAndProcessFlowDirection(processTaskVo, processTaskStepVo.getId(), ProcessFlowDirection.FORWARD)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotNextStepException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； if (!checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 步骤回退权限 @@ -396,7 +393,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -414,13 +411,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -433,25 +430,25 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //13.判断当前步骤是否有回退线，如果没有，则提示“该步骤未启用回退功能”； if (!checkNextStepIsExistsByProcessTaskStepIdAndProcessFlowDirection(processTaskVo, processTaskStepVo.getId(), ProcessFlowDirection.BACKWARD)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepBackNotEnabledException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //14.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； if (!checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 步骤暂存权限 @@ -465,7 +462,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -483,13 +480,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -502,19 +499,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； if (checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; }); /** * 步骤回复权限 @@ -524,7 +521,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { operationBiPredicateMap.put(ProcessTaskStepOperationType.STEP_COMMENT, (processTaskVo, processTaskStepVo, userUuid, operationTypePermissionDeniedExceptionMap, extraParam) -> { String processTaskStepEnableComment = ConfigManager.getConfig(ItsmTenantConfig.PROCESS_TASK_STEP_ENABLE_COMMENT); if (!Objects.equals(processTaskStepEnableComment, "1")) { - return false; + return PredicateResult.DENY; } Long id = processTaskStepVo.getId(); ProcessTaskStepOperationType operationType = ProcessTaskStepOperationType.STEP_COMMENT; @@ -532,7 +529,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -550,13 +547,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -569,19 +566,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； if (checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; }); /** * 步骤暂停权限 @@ -595,7 +592,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -613,13 +610,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -632,19 +629,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否有当前步骤“暂停”操作权限，如果没有，则提示“您的'暂停'操作未获得授权”； if (checkOperationAuthIsConfigured(processTaskVo, processTaskStepVo, operationType, userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; }); /** * 步骤恢复权限 @@ -658,7 +655,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -674,13 +671,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -693,19 +690,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否有当前步骤“暂停”操作权限，如果没有，则提示“您的'恢复'操作未获得授权”； if (checkOperationAuthIsConfigured(processTaskVo, processTaskStepVo, ProcessTaskStepOperationType.STEP_PAUSE, userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; }); /** * 步骤撤回权限 @@ -720,7 +717,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -738,32 +735,32 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤状态是否是“已完成”，如果不是，则提示“步骤未完成”； if (!ProcessTaskStatus.SUCCEED.getValue().equals(processTaskStepVo.getStatus())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepUndoneException()); - return false; + return PredicateResult.DENY; } //9.判断当前步骤的下一步骤是否已经完成，如果是，则提示“该步骤已经不能撤回”； if (!checkCurrentStepIsRetractableByProcessTaskStepId(processTaskVo, processTaskStepVo.getId())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepCannotRetreatException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //10.判断当前用户是否有当前步骤“撤回”操作权限，如果没有，则提示“您的'撤回'操作未获得授权”； // 撤销权限retreat if (!checkOperationAuthIsConfigured(processTaskVo, processTaskStepVo, operationType, userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 步骤重审权限 @@ -778,7 +775,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -796,13 +793,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -815,13 +812,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //13.判断当前步骤是否启用重审功能，如果没有，则提示“该步骤未启用重审功能”； if (!Objects.equals(processTaskStepVo.getEnableReapproval(), 1)){ operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepReapprovalNotEnabledException()); - return false; + return PredicateResult.DENY; } //14.判断当前步骤有没有对应需要重审的步骤，如果没有，则提示“没有需要重审的步骤”； boolean flag = false; @@ -838,19 +835,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (!flag) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNoNeedReapprovalStepException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //15.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； if (!checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 步骤处理权限 @@ -865,7 +862,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -883,13 +880,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -900,19 +897,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //12.判断当前用户是否是当前步骤的待处理人，如果不是，则提示“您不是步骤待处理人”； if (checkIsWorker(processTaskStepVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotWorkerException()); - return false; + return PredicateResult.DENY; }); /** @@ -928,7 +925,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -946,13 +943,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -965,19 +962,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //13.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； if (checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; }); /** @@ -993,7 +990,7 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -1011,13 +1008,13 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //8.判断步骤是否未激活，如果isActive=0，则提示“步骤未激活”； if (processTaskStepVo.getIsActive() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotActiveException()); - return false; + return PredicateResult.DENY; } //9.判断步骤状态是否是“已完成”，如果是，则提示“步骤已完成”； //10.判断步骤状态是否是“异常”，如果是，则提示“步骤异常”； @@ -1028,19 +1025,19 @@ public class StepOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //12.判断当前用户是否是当前步骤的处理人，如果不是，则提示“您不是步骤处理人”； if (checkIsProcessTaskStepUser(processTaskStepVo, ProcessUserType.MAJOR.getValue(), userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskStepNotMajorUserException()); - return false; + return PredicateResult.DENY; }); } diff --git a/src/main/java/neatlogic/module/process/operationauth/handler/TaskOperateHandler.java b/src/main/java/neatlogic/module/process/operationauth/handler/TaskOperateHandler.java index 66a351afeca5701da3f441e982dc30c837059dad..8388306618feac3c443d96375480aa320b4812c0 100644 --- a/src/main/java/neatlogic/module/process/operationauth/handler/TaskOperateHandler.java +++ b/src/main/java/neatlogic/module/process/operationauth/handler/TaskOperateHandler.java @@ -6,15 +6,12 @@ import neatlogic.framework.common.constvalue.SystemUser; import neatlogic.framework.dto.AuthenticationInfoVo; import neatlogic.framework.process.auth.PROCESSTASK_MODIFY; import neatlogic.framework.process.constvalue.*; -import neatlogic.framework.process.operationauth.core.IOperationType; +import neatlogic.framework.process.operationauth.core.*; import neatlogic.module.process.dao.mapper.catalog.CatalogMapper; import neatlogic.module.process.dao.mapper.catalog.ChannelMapper; import neatlogic.module.process.dao.mapper.catalog.ChannelTypeMapper; import neatlogic.framework.process.dto.*; import neatlogic.framework.process.exception.operationauth.*; -import neatlogic.framework.process.operationauth.core.OperationAuthHandlerBase; -import neatlogic.framework.process.operationauth.core.OperationAuthHandlerType; -import neatlogic.framework.process.operationauth.core.TernaryPredicate; import neatlogic.module.process.service.CatalogService; import neatlogic.module.process.service.ProcessTaskService; import com.alibaba.fastjson.JSONObject; @@ -66,7 +63,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (!AuthActionChecker.checkByUserUuid(userUuid, PROCESSTASK_MODIFY.class.getSimpleName()) && !SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； @@ -74,30 +71,30 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //4.依次判断当前用户是否是工单上报人、代报人、处理人、待处理人，如果都不是，执行第5步； if (userUuid.equals(processTaskVo.getOwner())) { - return true; + return PredicateResult.ACCEPT; } else if (userUuid.equals(processTaskVo.getReporter())) { - return true; + return PredicateResult.ACCEPT; } else if (checkIsProcessTaskStepUser(processTaskVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } else if (checkIsWorker(processTaskVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } //5.判断当前用户是否有工单对应服务的上报权限，如果没有，则提示“您没有【xxx】服务的上报权限”； if (catalogService.channelIsAuthority(processTaskVo.getChannelUuid(), userUuid, CatalogChannelAuthorityAction.VIEW)) { - return true; + return PredicateResult.ACCEPT; } ChannelVo channelVo = channelMapper.getChannelByUuid(processTaskVo.getChannelUuid()); operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotChannelViewException(channelVo.getName())); - return false; + return PredicateResult.DENY; }); /** * 工单提交权限 @@ -112,25 +109,25 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果不是，则提示“工单已提交”； if (!ProcessTaskStatus.DRAFT.getValue().equals(processTaskVo.getStatus())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskSubmittedException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //3.依次判断当前用户是否是工单上报人、代报人，如果都不是，则提示“您不是工单上报人或代报人”； if (userUuid.equals(processTaskVo.getOwner()) || userUuid.equals(processTaskVo.getReporter())) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotOwnerException()); - return false; + return PredicateResult.DENY; }); /** * 工单取消权限 @@ -145,7 +142,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -163,24 +160,24 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } // 工单状态为进行中、异常才能终止 if (ProcessTaskStatus.RUNNING.getValue().equals(processTaskVo.getStatus()) || ProcessTaskStatus.FAILED.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否有“取消”操作权限，如果没有，则提示“您的'取消'操作未获得授权”； if (!checkOperationAuthIsConfigured(processTaskVo, operationType, userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; } - return false; + return PredicateResult.DENY; }); /** * 工单恢复权限 @@ -195,7 +192,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -213,23 +210,23 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } // 工单状态为已终止的才能恢复 if (ProcessTaskStatus.ABORTED.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否有“取消”操作权限，如果没有，则提示“您的'恢复'操作未获得授权”； if (!checkOperationAuthIsConfigured(processTaskVo, ProcessTaskOperationType.PROCESSTASK_ABORT, userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; } - return false; + return PredicateResult.DENY; }); /** * 工单修改上报内容（包括标题、优先级、描述）权限 @@ -243,7 +240,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -261,22 +258,22 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } if (ProcessTaskStatus.RUNNING.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否有“修改上报内容”操作权限，如果没有，则提示“您的'修改上报内容'操作未获得授权”； if (!checkOperationAuthIsConfigured(processTaskVo, operationType, userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; } - return false; + return PredicateResult.DENY; }); /** * 工单催单权限 @@ -290,7 +287,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -308,22 +305,22 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } if (ProcessTaskStatus.RUNNING.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否有“催办”操作权限，如果没有，则提示“您的'催办'操作未获得授权”； if (!checkOperationAuthIsConfigured(processTaskVo, operationType, userUuid)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; } - return false; + return PredicateResult.DENY; }); /** * 工单处理权限 @@ -337,7 +334,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -355,23 +352,23 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } if (ProcessTaskStatus.RUNNING.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否是工单某个步骤的待处理人，如果不是，则提示“工单里没有您可以处理的步骤”； // 有可处理步骤work if (checkIsWorker(processTaskVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNoProcessableStepsException()); - return false; + return PredicateResult.DENY; } - return false; + return PredicateResult.DENY; }); /** * 工单撤回权限 @@ -386,7 +383,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -404,13 +401,13 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } // 撤销权限retreat if (ProcessTaskStatus.RUNNING.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否有工单某个步骤的撤回权限，如果没有，则提示“工单里没有您可以撤回的步骤”； boolean flag = false; @@ -418,17 +415,17 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskStep.getIsActive().intValue() == 1) { flag = checkIsRetractableStepByProcessTaskStepId(processTaskVo, processTaskStep.getId(), userUuid); if (flag) { - return true; + return PredicateResult.ACCEPT; } } } if (!flag) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNoRetreatableStepsException()); - return false; + return PredicateResult.DENY; } } - return false; + return PredicateResult.DENY; }); /** * 工单评分权限 @@ -442,33 +439,33 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“已完成”，如果不是，则提示“工单未完成”； if (!ProcessTaskStatus.SUCCEED.getValue().equals(processTaskVo.getStatus())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskUndoneException()); - return false; + return PredicateResult.DENY; } //3.判断工单是否启用“评分”功能，如果没有，则提示“工单未启用评分功能”； Integer isActive = (Integer) JSONPath.read(processTaskVo.getConfig(), "process.scoreConfig.isActive"); if (!Objects.equals(isActive, 1)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskScoreNotEnabledException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //4.依次判断当前用户是否是工单上报人、代报人，如果都不是，则提示“您不是工单上报人或代报人”； // 评分权限score if (!userUuid.equals(processTaskVo.getOwner()) && !userUuid.equals(processTaskVo.getReporter())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotOwnerException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 工单转报权限 @@ -483,7 +480,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单对应的服务是否启用转报功能，如果没有，则提示“工单对应的服务【"xxx"】未启用转报功能”； ChannelVo channelVo = channelMapper.getChannelByUuid(processTaskVo.getChannelUuid()); @@ -492,11 +489,11 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (!Objects.equals(allowTranferReport, 1)) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskChannelTransferReportNotEnabledException(channelVo.getName())); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //3.判断当前用户是否有“转报”操作权限，如果没有，则提示“您的'转报'操作未获得授权”； // boolean flag = processTaskService.checkTransferReportAuthorization(processTaskVo, userUuid); @@ -559,10 +556,10 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { } for (ChannelRelationVo channelRelation : channelRelationTargetList) { if ("channel".equals(channelRelation.getType())) { - return true; + return PredicateResult.ACCEPT; } else if ("catalog".equals(channelRelation.getType())) { if (channelTypeMapper.getActiveChannelCountByParentUuidAndChannelTypeUuidList(channelRelation.getTarget(), channelTypeUuidList) > 0) { - return true; + return PredicateResult.ACCEPT; } else { CatalogVo catalogVo = catalogMapper.getCatalogByUuid(channelRelation.getTarget()); if (catalogVo != null) { @@ -570,7 +567,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { for (String uuid : uuidList) { if (!channelRelation.getTarget().equals(uuid)) { if (channelTypeMapper.getActiveChannelCountByParentUuidAndChannelTypeUuidList(uuid, channelTypeUuidList) > 0) { - return true; + return PredicateResult.ACCEPT; } } } @@ -583,7 +580,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskOperationUnauthorizedException(operationType)); - return false; + return PredicateResult.DENY; }); /** @@ -597,16 +594,16 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单是否启用“标记重复事件”功能，如果没有，则提示“工单未启用标记重复事件功能”； Integer enableMarkRepeat = (Integer) JSONPath.read(processTaskVo.getConfig(), "process.processConfig.enableMarkRepeat"); if (Objects.equals(enableMarkRepeat, 1)) { - return true; + return PredicateResult.ACCEPT; } operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskMarkRepeatNotEnabledException()); - return false; + return PredicateResult.DENY; }); /** * 工单复制上报权限 @@ -621,20 +618,20 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //2.判断当前用户是否有工单对应服务的上报权限，如果没有，则提示“您没有【xxx】服务的上报权限”； if (catalogService.channelIsAuthority(processTaskVo.getChannelUuid(), userUuid, CatalogChannelAuthorityAction.REPORT)) { - return true; + return PredicateResult.ACCEPT; } ChannelVo channelVo = channelMapper.getChannelByUuid(processTaskVo.getChannelUuid()); operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotChannelReportException(channelVo.getName())); - return false; + return PredicateResult.DENY; }); /** * 工单重做权限 @@ -648,7 +645,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //4.判断工单状态是否是“处理中”，如果是，则提示“工单处理中”； @@ -666,7 +663,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } if (ProcessTaskStatus.SUCCEED.getValue().equals(processTaskVo.getStatus())) { //8.判断工单是否启用“重做”功能，如果没有，则提示“工单未启用重做功能”； @@ -680,21 +677,21 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (!flag) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskBackNotEnabledException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //9.依次判断当前用户是否是工单上报人、代报人，如果都不是，则提示“您不是工单上报人或代报人”； if (!userUuid.equals(processTaskVo.getOwner()) && !userUuid.equals(processTaskVo.getReporter())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotOwnerException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; } - return false; + return PredicateResult.DENY; }); /** * 工单转交权限 @@ -709,7 +706,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -727,12 +724,12 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } if (ProcessTaskStatus.RUNNING.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否有工单某个步骤的转交权限，如果没有，则提示“工单里没有您可以转交的步骤”； boolean flag = false; @@ -751,16 +748,16 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { } flag = checkOperationAuthIsConfigured(processTaskVo, processTaskStep, ProcessTaskStepOperationType.STEP_TRANSFER, userUuid); if (flag) { - return true; + return PredicateResult.ACCEPT; } } if (!flag) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNoTransferableStepsException()); - return false; + return PredicateResult.DENY; } } - return false; + return PredicateResult.DENY; }); /** @@ -773,19 +770,19 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 1) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskShownException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //2.判断当前用户是否有“工单管理权限”，如果没有，则提示“没有工单管理权限”； if (!AuthActionChecker.checkByUserUuid(userUuid, PROCESSTASK_MODIFY.class.getSimpleName())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotProcessTaskModifyException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 工单隐藏权限 @@ -797,19 +794,19 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //2.判断当前用户是否有“工单管理权限”，如果没有，则提示“没有工单管理权限”； if (!AuthActionChecker.checkByUserUuid(userUuid, PROCESSTASK_MODIFY.class.getSimpleName())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotProcessTaskModifyException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 工单删除权限 @@ -817,22 +814,22 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { operationBiPredicateMap.put(ProcessTaskOperationType.PROCESSTASK_DELETE, (processTaskVo, processTaskStepVo, userUuid, operationTypePermissionDeniedExceptionMap, extraParam) -> { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } Long id = processTaskVo.getId(); ProcessTaskOperationType operationType = ProcessTaskOperationType.PROCESSTASK_DELETE; //如果当前工单是草稿状态，则上报人允许删除 if (Objects.equals(ProcessTaskStatus.DRAFT.getValue(), processTaskVo.getStatus()) && Objects.equals(processTaskVo.getOwner(), UserContext.get().getUserUuid(true))) { - return true; + return PredicateResult.ACCEPT; } //2.判断当前用户是否有“工单管理权限”，如果没有，则提示“没有工单管理权限”； if (!AuthActionChecker.checkByUserUuid(userUuid, PROCESSTASK_MODIFY.class.getSimpleName())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotProcessTaskModifyException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** * 修改工单关注人权限 @@ -851,36 +848,36 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； if (ProcessTaskStatus.DRAFT.getValue().equals(processTaskVo.getStatus())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskUnsubmittedException()); - return false; + return PredicateResult.DENY; } //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //3.依次判断当前用户是否是工单上报人、代报人、处理人、待处理人，如果都不是，则提示“您不是工单干系人”； if (userUuid.equals(processTaskVo.getOwner())) { - return true; + return PredicateResult.ACCEPT; } else if (userUuid.equals(processTaskVo.getReporter())) { - return true; + return PredicateResult.ACCEPT; } else if (checkIsProcessTaskStepUser(processTaskVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } else if (checkIsWorker(processTaskVo, userUuid)) { - return true; + return PredicateResult.ACCEPT; } //4.判断当前用户是否有“工单管理权限”，如果没有，则提示“没有工单管理权限”； if (!AuthActionChecker.checkByUserUuid(userUuid, PROCESSTASK_MODIFY.class.getSimpleName())) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNotProcessTaskModifyException()); - return false; + return PredicateResult.DENY; } - return true; + return PredicateResult.ACCEPT; }); /** @@ -896,7 +893,7 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (processTaskVo.getIsShow() == 0) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskHiddenException()); - return false; + return PredicateResult.DENY; } //2.判断工单状态是否是“未提交”，如果是，则提示“工单未提交”； //3.判断工单状态是否是“已完成”，如果是，则提示“工单已完成”； @@ -914,12 +911,12 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { if (exception != null) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, exception); - return false; + return PredicateResult.DENY; } if (ProcessTaskStatus.RUNNING.getValue().equals(processTaskVo.getStatus())) { //系统用户默认拥有权限 if (SystemUser.SYSTEM.getUserUuid().equals(userUuid)) { - return true; + return PredicateResult.ACCEPT; } //8.判断当前用户是否有工单某个步骤的转交权限，如果没有，则提示“工单里没有您可以转交的步骤”； boolean flag = false; @@ -941,16 +938,16 @@ public class TaskOperateHandler extends OperationAuthHandlerBase { } flag = checkOperationAuthIsConfigured(processTaskVo, processTaskStep, ProcessTaskStepOperationType.STEP_TRANSFER, userUuid); if (flag) { - return true; + return PredicateResult.ACCEPT; } } if (!flag) { operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskNoTransferableStepsException()); - return false; + return PredicateResult.DENY; } } - return false; + return PredicateResult.DENY; }); } diff --git a/src/main/java/neatlogic/module/process/operationauth/handler/TimerOperateHandler.java b/src/main/java/neatlogic/module/process/operationauth/handler/TimerOperateHandler.java index 5bb6f92925e53725c4486a6622ab169cd2f7af3e..cf7e40fc34e453fc204c126b066c95c6a6d4d42f 100644 --- a/src/main/java/neatlogic/module/process/operationauth/handler/TimerOperateHandler.java +++ b/src/main/java/neatlogic/module/process/operationauth/handler/TimerOperateHandler.java @@ -1,14 +1,15 @@ package neatlogic.module.process.operationauth.handler; import com.alibaba.fastjson.JSONObject; -import neatlogic.framework.process.operationauth.core.IOperationType; +import neatlogic.framework.process.constvalue.ProcessStepHandlerType; import neatlogic.framework.process.constvalue.ProcessTaskStepOperationType; import neatlogic.framework.process.dto.ProcessTaskStepVo; import neatlogic.framework.process.dto.ProcessTaskVo; import neatlogic.framework.process.exception.operationauth.ProcessTaskPermissionDeniedException; import neatlogic.framework.process.exception.operationauth.ProcessTaskTimerHandlerNotEnableOperateException; +import neatlogic.framework.process.operationauth.core.IOperationType; import neatlogic.framework.process.operationauth.core.OperationAuthHandlerBase; -import neatlogic.framework.process.operationauth.core.OperationAuthHandlerType; +import neatlogic.framework.process.operationauth.core.PredicateResult; import neatlogic.framework.process.operationauth.core.TernaryPredicate; import org.springframework.stereotype.Component; @@ -31,7 +32,7 @@ public class TimerOperateHandler extends OperationAuthHandlerBase { //1.提示“定时节点不支持'撤回'操作”； operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskTimerHandlerNotEnableOperateException(operationType)); - return false; + return PredicateResult.DENY; }); operationBiPredicateMap.put(ProcessTaskStepOperationType.STEP_WORK, (processTaskVo, processTaskStepVo, userUuid, operationTypePermissionDeniedExceptionMap, extraParam) -> { @@ -40,7 +41,7 @@ public class TimerOperateHandler extends OperationAuthHandlerBase { //1.提示“定时节点不支持'处理'操作”； operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskTimerHandlerNotEnableOperateException(operationType)); - return false; + return PredicateResult.DENY; }); operationBiPredicateMap.put(ProcessTaskStepOperationType.STEP_COMMENT, (processTaskVo, processTaskStepVo, userUuid, operationTypePermissionDeniedExceptionMap, extraParam) -> { @@ -49,13 +50,13 @@ public class TimerOperateHandler extends OperationAuthHandlerBase { //1.提示“定时节点不支持'回复'操作”； operationTypePermissionDeniedExceptionMap.computeIfAbsent(id, key -> new HashMap<>()) .put(operationType, new ProcessTaskTimerHandlerNotEnableOperateException(operationType)); - return false; + return PredicateResult.DENY; }); } @Override public String getHandler() { - return OperationAuthHandlerType.TIMER.getValue(); + return ProcessStepHandlerType.TIMER.getHandler(); } @Override