授权申请回调处理修改

dcuc-auth-service/src/main/java/com/dragoninfo/dcuc/auth/business/impl/zerotrust/RoleAuthCallbackHandler.java

@@ -0,0 +1,48 @@
+package com.dragoninfo.dcuc.auth.business.impl.zerotrust;
+
+import com.dragoninfo.dcuc.auth.auth.dto.zerotrust.approval.ApprovalBaseRespDto;
+import com.dragoninfo.dcuc.auth.auth.entity.zerotrust.RoleAuthApply;
+import com.dragoninfo.dcuc.auth.auth.enumresources.zerotrust.approval.AuthApplyStatusEnum;
+import com.dragoninfo.dcuc.auth.auth.service.zerotrust.IRoleAuthApplyService;
+import com.dragoninfo.dcuc.auth.business.zerotrust.IRoleAuthCallbackHandler;
+import com.dragonsoft.duceap.commons.util.collections.CollectionUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * @author mazq
+ * @date 2023/11/24
+ */
+@Slf4j
+@Component
+public class RoleAuthCallbackHandler implements IRoleAuthCallbackHandler {
+
+    private IRoleAuthApplyService roleAuthApplyService;
+
+    @Autowired
+    public void setRoleAuthApplyService(IRoleAuthApplyService roleAuthApplyService) {
+        this.roleAuthApplyService = roleAuthApplyService;
+    }
+
+    @Override
+    public ApprovalBaseRespDto callBackHandle(String processInstId, String type, String applyStatus) {
+        log.info("开始处理角色权限申请");
+        List<RoleAuthApply> authApplies = roleAuthApplyService.getByProcessInstId(processInstId);
+        if (CollectionUtils.isEmpty(authApplies)) {
+            log.info("查询不到权限申请内容");
+            return new ApprovalBaseRespDto().success();
+        }
+        // 回调修改流程状态
+        roleAuthApplyService.updateApprovalResult(processInstId, applyStatus);
+
+        if (!AuthApplyStatusEnum.AGREE.getValue().equals(applyStatus)) {
+            return new ApprovalBaseRespDto().success();
+        }
+        // 角色授权暂时不做处理,只为演示审批风险。
+        return new ApprovalBaseRespDto().success();
+    }
+
+}

dcuc-auth-service/src/main/java/com/dragoninfo/dcuc/auth/business/impl/zerotrust/RoleOperateCallbackHandler.java

@@ -0,0 +1,117 @@
+package com.dragoninfo.dcuc.auth.business.impl.zerotrust;
+
+import com.dragoninfo.dcuc.auth.auth.dto.zerotrust.approval.ApprovalBaseRespDto;
+import com.dragoninfo.dcuc.auth.auth.entity.RoleInfo;
+import com.dragoninfo.dcuc.auth.auth.entity.zerotrust.RoleOperateContent;
+import com.dragoninfo.dcuc.auth.auth.enumresources.YesNotEnum;
+import com.dragoninfo.dcuc.auth.auth.enumresources.zerotrust.approval.AuthApplyStatusEnum;
+import com.dragoninfo.dcuc.auth.auth.enumresources.zerotrust.approval.FlowCallBackTypeEnum;
+import com.dragoninfo.dcuc.auth.auth.service.IRoleInfoService;
+import com.dragoninfo.dcuc.auth.auth.service.zerotrust.IRoleOperateApplyService;
+import com.dragoninfo.dcuc.auth.business.zerotrust.IRoleOperateCallbackHandler;
+import com.dragoninfo.dcuc.auth.sub.enumresource.OperateTypeEnum;
+import com.dragonsoft.duceap.base.enums.BooleanEnum;
+import com.dragonsoft.duceap.commons.util.string.StringUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author mazq
+ * @date 2023/11/24
+ */
+@Slf4j
+@Component
+public class RoleOperateCallbackHandler implements IRoleOperateCallbackHandler {
+
+    private IRoleInfoService roleInfoService;
+    private IRoleOperateApplyService roleOperateApplyService;
+
+    @Autowired
+    public void setRoleInfoService(IRoleInfoService roleInfoService) {
+        this.roleInfoService = roleInfoService;
+    }
+
+    @Autowired
+    public void setRoleOperateApplyService(IRoleOperateApplyService roleOperateApplyService) {
+        this.roleOperateApplyService = roleOperateApplyService;
+    }
+
+    @Override
+    public ApprovalBaseRespDto callBackHandle(String processInstId, String type, String applyStatus) {
+        RoleOperateContent roleOperateContent = roleOperateApplyService.getByProcessInstIdId(processInstId);
+        if (null == roleOperateContent) {
+            log.info("查询不到角色申请内容");
+            return new ApprovalBaseRespDto().success();
+        }
+
+        // 处理角色操作结果
+        return handleRoleOperateApproval(roleOperateContent, type, applyStatus);
+    }
+
+    private ApprovalBaseRespDto handleRoleOperateApproval(RoleOperateContent roleOperateContent, String type, String applyStatus) {
+        log.info("开始处理角色申请");
+        String id = roleOperateContent.getId();
+        // 流程被删除对应删除本地申请
+        if (FlowCallBackTypeEnum.DELETE.getValue().equals(type)) {
+            roleOperateApplyService.delete(roleOperateContent.getId());
+            return new ApprovalBaseRespDto().success();
+        }
+
+        // 回调修改流程状态
+        roleOperateApplyService.updateApprovalResult(id, applyStatus);
+
+        if (!AuthApplyStatusEnum.AGREE.getValue().equals(applyStatus)) {
+            return new ApprovalBaseRespDto().success();
+        }
+        // 开始操作角色
+        String operateType = roleOperateContent.getOperateType();
+        if (OperateTypeEnum.ADD.getValue().equals(operateType)) {
+            RoleInfo roleInfo = getNewRoleInfo(roleOperateContent);
+            // 判断角色代码是否重复
+            RoleInfo roleInfoByCode = roleInfoService.getByAppIdAndCode(roleInfo.getAppId(), roleInfo.getCode());
+            if (null != roleInfoByCode) {
+                log.info("角色代码已存在:{}", roleInfo.getCode());
+            } else {
+                log.info("保存新增角色");
+                roleInfoService.save(roleInfo);
+            }
+        } else if (OperateTypeEnum.DELETE.getValue().equals(operateType)) {
+            log.info("删除角色:{}", roleOperateContent.getRoleId());
+            roleInfoService.deleteRole(roleOperateContent.getRoleId());
+        } else if (OperateTypeEnum.UPDATE.getValue().equals(operateType)) {
+            RoleInfo roleInfo = getNewRoleInfo(roleOperateContent);
+            roleInfo.setId(roleOperateContent.getRoleId());
+            // 判断角色代码是否重复
+            RoleInfo roleInfoByCode = roleInfoService.getByAppIdAndCode(roleInfo.getAppId(), roleInfo.getCode());
+            if (null != roleInfoByCode && !roleInfoByCode.getId().equals(roleInfo.getId())) {
+                log.info("角色代码已存在");
+            } else {
+                log.info("更新角色:{}", roleInfo.getId());
+                roleInfoService.update(roleInfo);
+            }
+        }
+
+        return new ApprovalBaseRespDto().success();
+    }
+
+    private RoleInfo getNewRoleInfo(RoleOperateContent roleOperateContent) {
+        RoleInfo roleInfo = new RoleInfo();
+        roleInfo.setAppId(roleOperateContent.getAppId());
+        roleInfo.setName(roleOperateContent.getName());
+        roleInfo.setCode(roleOperateContent.getCode());
+        roleInfo.setRoleLevel(roleOperateContent.getRoleLevel());
+        roleInfo.setRoleCategory(roleOperateContent.getRoleCategory());
+        roleInfo.setRoleBusiness(roleOperateContent.getRoleBusiness());
+        roleInfo.setPoliceCategory(roleOperateContent.getPoliceCategory());
+        String limitCount = roleOperateContent.getLimitCount();
+        if (StringUtils.isNotBlank(limitCount)) {
+            roleInfo.setIsNotLimitCount(
+                    YesNotEnum.YES.getValue().equals(limitCount) ? "0" : "1");
+        }
+        roleInfo.setIsActive(BooleanEnum.TRUE.value);
+        return roleInfo;
+    }
+
+
+}

dcuc-auth-service/src/main/java/com/dragoninfo/dcuc/auth/business/impl/zerotrust/ServiceAuthCallbackHandler.java

@@ -0,0 +1,47 @@
+package com.dragoninfo.dcuc.auth.business.impl.zerotrust;
+
+import com.dragoninfo.dcuc.auth.auth.dto.zerotrust.approval.ApprovalBaseRespDto;
+import com.dragoninfo.dcuc.auth.auth.entity.zerotrust.ServiceAuthApply;
+import com.dragoninfo.dcuc.auth.auth.enumresources.zerotrust.approval.AuthApplyStatusEnum;
+import com.dragoninfo.dcuc.auth.auth.service.zerotrust.IServiceAuthApplyService;
+import com.dragoninfo.dcuc.auth.business.zerotrust.IServiceAuthCallbackHandler;
+import com.dragonsoft.duceap.commons.util.collections.CollectionUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * @author mazq
+ * @date 2023/11/24
+ */
+@Slf4j
+@Component
+public class ServiceAuthCallbackHandler implements IServiceAuthCallbackHandler {
+
+    private IServiceAuthApplyService serviceAuthApplyService;
+
+    @Autowired
+    public void setServiceAuthApplyService(IServiceAuthApplyService serviceAuthApplyService) {
+        this.serviceAuthApplyService = serviceAuthApplyService;
+    }
+
+    @Override
+    public ApprovalBaseRespDto callBackHandle(String processInstId, String type, String applyStatus) {
+        log.info("开始处理服务权限申请");
+        List<ServiceAuthApply> authApplies = serviceAuthApplyService.getByProcessInstId(processInstId);
+        if (CollectionUtils.isEmpty(authApplies)) {
+            log.info("查询不到权限申请内容");
+            return new ApprovalBaseRespDto().success();
+        }
+        // 回调修改流程状态
+        serviceAuthApplyService.updateApprovalResult(processInstId, applyStatus);
+
+        if (!AuthApplyStatusEnum.AGREE.getValue().equals(applyStatus)) {
+            return new ApprovalBaseRespDto().success();
+        }
+        // 服务授权暂时不做处理,只为演示审批风险。
+        return new ApprovalBaseRespDto().success();
+    }
+}

dcuc-auth-service/src/main/java/com/dragoninfo/dcuc/auth/business/impl/zerotrust/ZeroTrustApprovalBusinessImpl.java

@@ -9,22 +9,13 @@ import com.dragoninfo.dcuc.auth.api.enums.zerotrust.ZeroTrustBusinessRespEnum;
 import com.dragoninfo.dcuc.auth.api.vo.zerotrust.ZeroTrustMessageRespVO;
 import com.dragoninfo.dcuc.auth.auth.constance.zerotrust.approval.ApprovalConstance;
 import com.dragoninfo.dcuc.auth.auth.dto.zerotrust.approval.*;
-import com.dragoninfo.dcuc.auth.auth.entity.RoleInfo;
 import com.dragoninfo.dcuc.auth.auth.entity.zerotrust.ApprovalResult;
-import com.dragoninfo.dcuc.auth.auth.entity.zerotrust.RoleAuthApply;
-import com.dragoninfo.dcuc.auth.auth.entity.zerotrust.RoleOperateContent;
-import com.dragoninfo.dcuc.auth.auth.enumresources.YesNotEnum;
 import com.dragoninfo.dcuc.auth.auth.enumresources.zerotrust.approval.*;
-import com.dragoninfo.dcuc.auth.auth.service.IRoleInfoService;
 import com.dragoninfo.dcuc.auth.auth.service.zerotrust.IApprovalResultService;
-import com.dragoninfo.dcuc.auth.auth.service.zerotrust.IRoleAuthApplyService;
-import com.dragoninfo.dcuc.auth.auth.service.zerotrust.IRoleOperateApplyService;
 import com.dragoninfo.dcuc.auth.auth.vo.zerotrust.approval.ApprovalCallBackReqVO;
-import com.dragoninfo.dcuc.auth.business.zerotrust.IZeroTrustApprovalBusiness;
-import com.dragoninfo.dcuc.auth.business.zerotrust.IApproveRemoteCallBusiness;
+import com.dragoninfo.dcuc.auth.business.zerotrust.*;
 import com.dragoninfo.dcuc.auth.config.zerotrust.ApprovalProperties;
 import com.dragoninfo.dcuc.auth.constance.ZerotrustAuthRedisConstant;
-import com.dragoninfo.dcuc.auth.sub.enumresource.OperateTypeEnum;
 import com.dragoninfo.dcuc.common.enums.UserExtInfoEnum;
 import com.dragoninfo.dcuc.common.utils.ResponseUtil;
 import com.dragoninfo.dcuc.common.utils.SecurityUserUtil;
@@ -33,7 +24,6 @@ import com.dragonsoft.duceap.base.entity.http.ResponseStatus;
 import com.dragonsoft.duceap.base.enums.BooleanEnum;
 import com.dragonsoft.duceap.base.utils.UserContextUtils;
 import com.dragonsoft.duceap.commons.util.ObjectUtils;
-import com.dragonsoft.duceap.commons.util.collections.CollectionUtils;
 import com.dragonsoft.duceap.commons.util.date.DateConst;
 import com.dragonsoft.duceap.commons.util.date.DateUtils;
 import com.dragonsoft.duceap.commons.util.enums.EnumUtils;
@@ -59,23 +49,34 @@ import java.util.concurrent.TimeUnit;
 @Service
 public class ZeroTrustApprovalBusinessImpl implements IZeroTrustApprovalBusiness {
 
-    private IRoleInfoService roleInfoService;
-
     private ApprovalProperties approvalProperties;
 
-    private IRoleOperateApplyService roleOperateApplyService;
-
     private IApprovalResultService approvalResultService;
 
     private StringRedisTemplate stringRedisTemplate;
 
     private IApproveRemoteCallBusiness approveRemoteCallBusiness;
 
-    private IRoleAuthApplyService roleAuthApplyService;
+    private IRoleOperateCallbackHandler roleOperateCallbackHandler;
+
+    private IServiceAuthCallbackHandler serviceAuthCallbackHandler;
+
+    private IRoleAuthCallbackHandler roleAuthCallbackHandler;
+
+
+    @Autowired
+    public void setRoleOperateCallbackHandler(IRoleOperateCallbackHandler roleOperateCallbackHandler) {
+        this.roleOperateCallbackHandler = roleOperateCallbackHandler;
+    }
+
+    @Autowired
+    public void setServiceAuthCallbackHandler(IServiceAuthCallbackHandler serviceAuthCallbackHandler) {
+        this.serviceAuthCallbackHandler = serviceAuthCallbackHandler;
+    }
 
     @Autowired
-    public void setRoleAuthApplyService(IRoleAuthApplyService roleAuthApplyService) {
-        this.roleAuthApplyService = roleAuthApplyService;
+    public void setRoleAuthCallbackHandler(IRoleAuthCallbackHandler roleAuthCallbackHandler) {
+        this.roleAuthCallbackHandler = roleAuthCallbackHandler;
     }
 
     @Autowired
@@ -93,21 +94,11 @@ public class ZeroTrustApprovalBusinessImpl implements IZeroTrustApprovalBusiness
         this.approvalResultService = approvalResultService;
     }
 
-    @Autowired
-    public void setRoleInfoService(IRoleInfoService roleInfoService) {
-        this.roleInfoService = roleInfoService;
-    }
-
     @Autowired
     public void setApprovalProperties(ApprovalProperties approvalProperties) {
         this.approvalProperties = approvalProperties;
     }
 
-    @Autowired
-    public void setRoleOperateApplyService(IRoleOperateApplyService roleOperateApplyService) {
-        this.roleOperateApplyService = roleOperateApplyService;
-    }
-
     @Override
     public ResponseDTO<FlowApplyRespDTO> approvalFlowApply(FlowApplyReqDto flowApplyReqDto, String businessKey) {
         String appTokenId = SecurityUserUtil.getUserExtInfoValue(UserExtInfoEnum.APP_TOKEN_ID);
@@ -296,10 +287,13 @@ public class ZeroTrustApprovalBusinessImpl implements IZeroTrustApprovalBusiness
 
             // 角色操作申请处理
             ApprovalBaseRespDto approvalBaseRespDto = new ApprovalBaseRespDto().success();
+            String applyStatus = getApplyStatus(type, endFlag);
             if (ApprovalApplyTypeEnum.ROLE_OPERATE.getValue().equals(applyType)) {
-                approvalBaseRespDto = roleOperateCallBackHandle(processInstId, type, endFlag);
+                approvalBaseRespDto = roleOperateCallbackHandler.callBackHandle(processInstId, type, applyStatus);
             } else if (ApprovalApplyTypeEnum.ROLE_AUTH_APPLY.getValue().equals(applyType)) {
-                approvalBaseRespDto = roleAuthCallBackHandle(processInstId, type, endFlag);
+                approvalBaseRespDto = roleAuthCallbackHandler.callBackHandle(processInstId, type, applyStatus);
+            } else if (ApprovalApplyTypeEnum.SERVICE_AUTH_APPLY.getValue().equals(applyType)) {
+                approvalBaseRespDto = serviceAuthCallbackHandler.callBackHandle(processInstId, type, applyStatus);
             }
 
             // 更新审批结果
@@ -314,106 +308,12 @@ public class ZeroTrustApprovalBusinessImpl implements IZeroTrustApprovalBusiness
 
     }
 
-    private ApprovalBaseRespDto roleAuthCallBackHandle(String processInstId, String type, String endFlag) {
-        log.info("开始处理角色权限申请");
-        List<RoleAuthApply> authApplies = roleAuthApplyService.getByProcessInstId(processInstId);
-        if (CollectionUtils.isEmpty(authApplies)) {
-            log.info("查询不到权限申请内容");
-            return new ApprovalBaseRespDto().success();
-        }
-        // 回调修改流程状态
-        String approvalResult = getApplyStatus(type, endFlag);
-        roleAuthApplyService.updateApprovalResult(processInstId, approvalResult);
-
-        if (!AuthApplyStatusEnum.AGREE.getValue().equals(approvalResult)) {
-            return new ApprovalBaseRespDto().success();
-        }
-        // 角色授权暂时不做处理,只为演示审批风险。
-        return new ApprovalBaseRespDto().success();
-    }
-
     private void updateApprovalResult(ApprovalResult approvalResult, ApprovalCallBackReqVO approvalCallBackReqVO) {
         BeanUtil.copyProperties(approvalCallBackReqVO, approvalResult, "taskId", "businessKey");
         approvalResult.setCallBack(BooleanEnum.TRUE.value);
         approvalResultService.update(approvalResult);
     }
 
-    private ApprovalBaseRespDto roleOperateCallBackHandle(String processInstId, String type, String endFlag) {
-        RoleOperateContent roleOperateContent = roleOperateApplyService.getByProcessInstIdId(processInstId);
-        if (null == roleOperateContent) {
-            log.info("查询不到角色申请内容");
-            return new ApprovalBaseRespDto().success();
-        }
-
-        // 处理角色操作结果
-        return handleRoleOperateApproval(roleOperateContent, type, endFlag);
-    }
-
-    private ApprovalBaseRespDto handleRoleOperateApproval(RoleOperateContent roleOperateContent, String type, String endFlag) {
-        log.info("开始处理角色申请");
-        String id = roleOperateContent.getId();
-        // 流程被删除对应删除本地申请
-        if (FlowCallBackTypeEnum.DELETE.getValue().equals(type)) {
-            roleOperateApplyService.delete(roleOperateContent.getId());
-            return new ApprovalBaseRespDto().success();
-        }
-
-        // 回调修改流程状态
-        String approvalResult = getApplyStatus(type, endFlag);
-        roleOperateApplyService.updateApprovalResult(id, approvalResult);
-
-        if (!AuthApplyStatusEnum.AGREE.getValue().equals(approvalResult)) {
-            return new ApprovalBaseRespDto().success();
-        }
-        // 开始操作角色
-        String operateType = roleOperateContent.getOperateType();
-        if (OperateTypeEnum.ADD.getValue().equals(operateType)) {
-            RoleInfo roleInfo = getNewRoleInfo(roleOperateContent);
-            // 判断角色代码是否重复
-            RoleInfo roleInfoByCode = roleInfoService.getByAppIdAndCode(roleInfo.getAppId(), roleInfo.getCode());
-            if (null != roleInfoByCode) {
-                log.info("角色代码已存在:{}", roleInfo.getCode());
-            } else {
-                log.info("保存新增角色");
-                roleInfoService.save(roleInfo);
-            }
-        } else if (OperateTypeEnum.DELETE.getValue().equals(operateType)) {
-            log.info("删除角色:{}", roleOperateContent.getRoleId());
-            roleInfoService.deleteRole(roleOperateContent.getRoleId());
-        } else if (OperateTypeEnum.UPDATE.getValue().equals(operateType)) {
-            RoleInfo roleInfo = getNewRoleInfo(roleOperateContent);
-            roleInfo.setId(roleOperateContent.getRoleId());
-            // 判断角色代码是否重复
-            RoleInfo roleInfoByCode = roleInfoService.getByAppIdAndCode(roleInfo.getAppId(), roleInfo.getCode());
-            if (null != roleInfoByCode && !roleInfoByCode.getId().equals(roleInfo.getId())) {
-                log.info("角色代码已存在");
-            } else {
-                log.info("更新角色:{}", roleInfo.getId());
-                roleInfoService.update(roleInfo);
-            }
-        }
-
-        return new ApprovalBaseRespDto().success();
-    }
-
-    private RoleInfo getNewRoleInfo(RoleOperateContent roleOperateContent) {
-        RoleInfo roleInfo = new RoleInfo();
-        roleInfo.setAppId(roleOperateContent.getAppId());
-        roleInfo.setName(roleOperateContent.getName());
-        roleInfo.setCode(roleOperateContent.getCode());
-        roleInfo.setRoleLevel(roleOperateContent.getRoleLevel());
-        roleInfo.setRoleCategory(roleOperateContent.getRoleCategory());
-        roleInfo.setRoleBusiness(roleOperateContent.getRoleBusiness());
-        roleInfo.setPoliceCategory(roleOperateContent.getPoliceCategory());
-        String limitCount = roleOperateContent.getLimitCount();
-        if (StringUtils.isNotBlank(limitCount)) {
-            roleInfo.setIsNotLimitCount(
-                    YesNotEnum.YES.getValue().equals(limitCount) ? "0" : "1");
-        }
-        roleInfo.setIsActive(BooleanEnum.TRUE.value);
-        return roleInfo;
-    }
-
     private String getApplyStatus(String type, String endFlag) {
         String applyStatus = "";
         if (FlowCallBackTypeEnum.CANCEL.getValue().equals(type)) {

dcuc-auth-service/src/main/java/com/dragoninfo/dcuc/auth/business/zerotrust/IRoleAuthCallbackHandler.java

@@ -0,0 +1,11 @@
+package com.dragoninfo.dcuc.auth.business.zerotrust;
+
+import com.dragoninfo.dcuc.auth.auth.dto.zerotrust.approval.ApprovalBaseRespDto;
+
+/**
+ * @author mazq
+ * @date 2023/11/24
+ */
+public interface IRoleAuthCallbackHandler {
+    ApprovalBaseRespDto callBackHandle(String processInstId, String type, String applyStatus);
+}

dcuc-auth-service/src/main/java/com/dragoninfo/dcuc/auth/business/zerotrust/IRoleOperateCallbackHandler.java

@@ -0,0 +1,11 @@
+package com.dragoninfo.dcuc.auth.business.zerotrust;
+
+import com.dragoninfo.dcuc.auth.auth.dto.zerotrust.approval.ApprovalBaseRespDto;
+
+/**
+ * @author mazq
+ * @date 2023/11/24
+ */
+public interface IRoleOperateCallbackHandler {
+    ApprovalBaseRespDto callBackHandle(String processInstId, String type, String applyStatus);
+}

dcuc-auth-service/src/main/java/com/dragoninfo/dcuc/auth/business/zerotrust/IServiceAuthCallbackHandler.java

@@ -0,0 +1,11 @@
+package com.dragoninfo.dcuc.auth.business.zerotrust;
+
+import com.dragoninfo.dcuc.auth.auth.dto.zerotrust.approval.ApprovalBaseRespDto;
+
+/**
+ * @author mazq
+ * @date 2023/11/24
+ */
+public interface IServiceAuthCallbackHandler {
+    ApprovalBaseRespDto callBackHandle(String processInstId, String type, String applyStatus);
+}