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 5c8840a2f2ad4083c14e31e8e95cb77825b1ec8e..5f993f22839bbe2d03de7b11fa452cb91b865e34 100644
--- a/src/main/java/neatlogic/module/process/operationauth/handler/TaskOperateHandler.java
+++ b/src/main/java/neatlogic/module/process/operationauth/handler/TaskOperateHandler.java
@@ -736,11 +736,21 @@ public class TaskOperateHandler extends OperationAuthHandlerBase {
                 //8.判断当前用户是否有工单某个步骤的转交权限，如果没有，则提示“工单里没有您可以转交的步骤”；
                 boolean flag = false;
                 for (ProcessTaskStepVo processTaskStep : processTaskVo.getStepList()) {
-                    if (processTaskStep.getIsActive().intValue() == 1) {
-                        flag = checkOperationAuthIsConfigured(processTaskVo, processTaskStep, ProcessTaskOperationType.STEP_TRANSFER, userUuid);
-                        if (flag) {
-                            return true;
-                        }
+                    // 步骤状态为已激活的才能转交，否则跳过；
+                    if (!Objects.equals(processTaskStep.getIsActive(), 1)) {
+                        continue;
+                    }
+                    //9.判断步骤状态是否是“已完成”，如果是，则跳过；
+                    //10.判断步骤状态是否是“异常”，如果是，则跳过；
+                    //11.判断步骤状态是否是“已挂起”，如果是，则跳过；
+                    if (processTaskService.checkProcessTaskStepStatus(processTaskStep.getStatus(), ProcessTaskStepStatus.SUCCEED,
+                            ProcessTaskStepStatus.FAILED,
+                            ProcessTaskStepStatus.HANG) != null) {
+                        continue;
+                    }
+                    flag = checkOperationAuthIsConfigured(processTaskVo, processTaskStep, ProcessTaskOperationType.STEP_TRANSFER, userUuid);
+                    if (flag) {
+                        return true;
                     }
                 }
                 if (!flag) {
diff --git a/src/main/java/neatlogic/module/process/service/ProcessTaskService.java b/src/main/java/neatlogic/module/process/service/ProcessTaskService.java
index e997175c81df77efbdd66396d0eb487b300d17f5..d158498c08242a4e97270c7a732712c4592db4f2 100644
--- a/src/main/java/neatlogic/module/process/service/ProcessTaskService.java
+++ b/src/main/java/neatlogic/module/process/service/ProcessTaskService.java
@@ -519,4 +519,10 @@ public interface ProcessTaskService {
      * @return
      */
     JSONObject getProcessTaskStepStagingData(Long processTaskId, Long processTaskStepId);
+
+    /**
+     * 检查步骤是否是无效的，如果一个步骤A前面有两条路径，一个步骤B，一个是步骤C，如果选择流转到步骤B，且步骤C不会再被激活，那么步骤C就是无效的步骤
+     * @return 如果是无效步骤返回true，否则返回false
+     */
+    boolean checkStepIsInvalid(Long processTaskStepId);
 }
diff --git a/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java b/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java
index 0f8581d22804312a290bf913ebd6f532c360d5b8..ec6900014cbfabacd1c80eb51dc240ab9fd1b2a3 100644
--- a/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java
+++ b/src/main/java/neatlogic/module/process/service/ProcessTaskServiceImpl.java
@@ -1374,12 +1374,21 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC
         List<ProcessTaskStepVo> stepVoList =
                 processTaskMapper.getProcessTaskStepBaseInfoByProcessTaskId(processTaskVo.getId());
         for (ProcessTaskStepVo stepVo : stepVoList) {
-            /* 找到所有已激活步骤 **/
-            if (stepVo.getIsActive().equals(1)) {
-                if (checkOperationAuthIsConfigured(stepVo, processTaskVo.getOwner(), processTaskVo.getReporter(),
-                        ProcessTaskOperationType.STEP_TRANSFER, userUuid)) {
-                    resultSet.add(stepVo);
-                }
+            // 步骤状态为已激活的才能转交，否则跳过；
+            if (!Objects.equals(stepVo.getIsActive(), 1)) {
+                continue;
+            }
+            //9.判断步骤状态是否是“已完成”，如果是，则跳过；
+            //10.判断步骤状态是否是“异常”，如果是，则跳过；
+            //11.判断步骤状态是否是“已挂起”，如果是，则跳过；
+            if (checkProcessTaskStepStatus(stepVo.getStatus(), ProcessTaskStepStatus.SUCCEED,
+                    ProcessTaskStepStatus.FAILED,
+                    ProcessTaskStepStatus.HANG) != null) {
+                continue;
+            }
+            if (checkOperationAuthIsConfigured(stepVo, processTaskVo.getOwner(), processTaskVo.getReporter(),
+                    ProcessTaskOperationType.STEP_TRANSFER, userUuid)) {
+                resultSet.add(stepVo);
             }
         }
         return resultSet;
@@ -3256,4 +3265,16 @@ public class ProcessTaskServiceImpl implements ProcessTaskService, IProcessTaskC
         }
         return data;
     }
+
+    @Override
+    public boolean checkStepIsInvalid(Long processTaskStepId) {
+        List<ProcessTaskStepRelVo> processTaskStepRelList = processTaskMapper.getProcessTaskStepRelByFromId(processTaskStepId);
+        for (ProcessTaskStepRelVo processTaskStepRelVo : processTaskStepRelList) {
+            if (Objects.equals(processTaskStepRelVo.getType(), ProcessFlowDirection.FORWARD.getValue())
+                    && !Objects.equals(processTaskStepRelVo.getIsHit(), -1)) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
diff --git a/src/main/java/neatlogic/module/process/sla/handler/DefaultSlaCalculateHandler.java b/src/main/java/neatlogic/module/process/sla/handler/DefaultSlaCalculateHandler.java
index 83efad2784b13972b5fd4371508aae2adb80fd3b..99412006b816f5ee189c869a0ff1ab900d56ee75 100644
--- a/src/main/java/neatlogic/module/process/sla/handler/DefaultSlaCalculateHandler.java
+++ b/src/main/java/neatlogic/module/process/sla/handler/DefaultSlaCalculateHandler.java
@@ -119,7 +119,8 @@ public class DefaultSlaCalculateHandler extends SlaCalculateHandlerBase {
      */
     private static List<Map<String, Long>> timeAuditListToTimePeriodList(List<ProcessTaskStepTimeAuditVo> timeAuditList, long currentTimeMillis) {
         List<Map<String, Long>> timeList = new ArrayList<>();
-        for (ProcessTaskStepTimeAuditVo auditVo : timeAuditList) {
+        for (int i = 0; i < timeAuditList.size(); i++) {
+            ProcessTaskStepTimeAuditVo auditVo = timeAuditList.get(i);
             Long startTime = null;
             Long endTime = null;
             if (auditVo.getActiveTimeLong() != null) {
@@ -147,9 +148,11 @@ public class DefaultSlaCalculateHandler extends SlaCalculateHandlerBase {
                 Map<String, Long> stimeMap = new HashMap<>();
                 stimeMap.put("s", startTime);
                 timeList.add(stimeMap);
-                Map<String, Long> etimeMap = new HashMap<>();
-                etimeMap.put("e", currentTimeMillis);
-                timeList.add(etimeMap);
+                if (i == timeAuditList.size() - 1) {
+                    Map<String, Long> etimeMap = new HashMap<>();
+                    etimeMap.put("e", currentTimeMillis);
+                    timeList.add(etimeMap);
+                }
             }
         }
         timeList.sort((o1, o2) -> {
@@ -171,7 +174,7 @@ public class DefaultSlaCalculateHandler extends SlaCalculateHandlerBase {
             if (s != null) {
                 timeStack.push(s);
             } else if (e != null) {
-                if (!timeStack.isEmpty()) {
+                while (!timeStack.isEmpty()) {
                     Long currentStartTimeLong = timeStack.pop();
                     if (timeStack.isEmpty()) {// 栈被清空时计算时间段
                         Map<String, Long> newTimeMap = new HashMap<>();
diff --git a/src/main/java/neatlogic/module/process/thread/ProcessTaskSlaThread.java b/src/main/java/neatlogic/module/process/thread/ProcessTaskSlaThread.java
index 73131d1806ffe234b336f15f54b9ebdd32a793ea..d918a56b95c04b529c38bc31fec3e189ab122beb 100644
--- a/src/main/java/neatlogic/module/process/thread/ProcessTaskSlaThread.java
+++ b/src/main/java/neatlogic/module/process/thread/ProcessTaskSlaThread.java
@@ -15,34 +15,34 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.*/
 
 package neatlogic.module.process.thread;
 
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.JSONPath;
 import neatlogic.framework.asynchronization.thread.NeatLogicThread;
 import neatlogic.framework.asynchronization.threadlocal.ConditionParamContext;
 import neatlogic.framework.asynchronization.threadlocal.TenantContext;
 import neatlogic.framework.dto.condition.ConditionConfigVo;
 import neatlogic.framework.process.condition.core.ProcessTaskConditionFactory;
 import neatlogic.framework.process.constvalue.ConditionProcessTaskOptions;
-import neatlogic.framework.process.constvalue.ProcessFlowDirection;
 import neatlogic.framework.process.constvalue.SlaStatus;
-import neatlogic.module.process.dao.mapper.processtask.ProcessTaskMapper;
-import neatlogic.module.process.dao.mapper.processtask.ProcessTaskSlaMapper;
+import neatlogic.framework.process.dto.*;
 import neatlogic.framework.process.exception.sla.SlaCalculateHandlerNotFoundException;
 import neatlogic.framework.process.sla.core.ISlaCalculateHandler;
 import neatlogic.framework.process.sla.core.SlaCalculateHandlerFactory;
-import neatlogic.framework.process.dto.*;
-import neatlogic.module.process.schedule.plugin.ProcessTaskSlaNotifyJob;
-import neatlogic.module.process.schedule.plugin.ProcessTaskSlaTransferJob;
-import neatlogic.framework.util.WorkTimeUtil;
 import neatlogic.framework.scheduler.core.IJob;
 import neatlogic.framework.scheduler.core.SchedulerManager;
 import neatlogic.framework.scheduler.dto.JobObject;
 import neatlogic.framework.scheduler.exception.ScheduleHandlerNotFoundException;
 import neatlogic.framework.transaction.util.TransactionUtil;
 import neatlogic.framework.util.RunScriptUtil;
+import neatlogic.framework.util.WorkTimeUtil;
+import neatlogic.module.process.dao.mapper.processtask.ProcessTaskMapper;
+import neatlogic.module.process.dao.mapper.processtask.ProcessTaskSlaMapper;
+import neatlogic.module.process.schedule.plugin.ProcessTaskSlaNotifyJob;
+import neatlogic.module.process.schedule.plugin.ProcessTaskSlaTransferJob;
+import neatlogic.module.process.service.ProcessTaskService;
 import neatlogic.module.process.sla.handler.DefaultSlaCalculateHandler;
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
-import com.alibaba.fastjson.JSONPath;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.collections4.MapUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -64,12 +64,12 @@ public class ProcessTaskSlaThread extends NeatLogicThread {
     private static TransactionUtil transactionUtil;
 
     private static SchedulerManager schedulerManager;
-//    private static ProcessTaskService processTaskService;
+    private static ProcessTaskService processTaskService;
 
-//    @Resource
-//    public void setProcessTaskService(ProcessTaskService _processTaskService) {
-//        processTaskService = _processTaskService;
-//    }
+    @Resource
+    public void setProcessTaskService(ProcessTaskService _processTaskService) {
+        processTaskService = _processTaskService;
+    }
 
     @Resource
     public void setProcessTaskMapper(ProcessTaskMapper _processTaskMapper) {
@@ -444,20 +444,28 @@ public class ProcessTaskSlaThread extends NeatLogicThread {
                 // 时效关联开始步骤，则一定会被激活
                 isActive = true;
             } else {
-                for (Long processTaskStepId : processTaskStepIdList) {
-                    List<ProcessTaskStepRelVo> processTaskStepRelList = processTaskMapper.getProcessTaskStepRelByToId(processTaskStepId);
-                    for (ProcessTaskStepRelVo processTaskStepRelVo : processTaskStepRelList) {
-                        if (processTaskStepRelVo.getType().equals(ProcessFlowDirection.FORWARD.getValue())) {
-                            if (!Objects.equals(processTaskStepRelVo.getIsHit(), -1)) {
-                                isActive = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (isActive) {
-                        break;
+                for (int i = processTaskStepIdList.size() - 1; i >= 0; i--) {
+                    if (processTaskService.checkStepIsInvalid(processTaskStepIdList.get(i))) {
+                        processTaskStepIdList.remove(i);
                     }
                 }
+                if (CollectionUtils.isNotEmpty(processTaskStepIdList)) {
+                    isActive = true;
+                }
+//                for (Long processTaskStepId : processTaskStepIdList) {
+//                    List<ProcessTaskStepRelVo> processTaskStepRelList = processTaskMapper.getProcessTaskStepRelByToId(processTaskStepId);
+//                    for (ProcessTaskStepRelVo processTaskStepRelVo : processTaskStepRelList) {
+//                        if (processTaskStepRelVo.getType().equals(ProcessFlowDirection.FORWARD.getValue())) {
+//                            if (!Objects.equals(processTaskStepRelVo.getIsHit(), -1)) {
+//                                isActive = true;
+//                                break;
+//                            }
+//                        }
+//                    }
+//                    if (isActive) {
+//                        break;
+//                    }
+//                }
             }
             if (isActive) {
                 resultList.add(slaId);
@@ -491,6 +499,11 @@ public class ProcessTaskSlaThread extends NeatLogicThread {
         }
         List<ProcessTaskStepVo> processTaskStepList = new ArrayList<>();
         List<Long> processTaskStepIdList = processTaskSlaMapper.getProcessTaskStepIdListBySlaId(slaId);
+        for (int i = processTaskStepIdList.size() - 1; i >= 0; i--) {
+            if (processTaskService.checkStepIsInvalid(processTaskStepIdList.get(i))) {
+                processTaskStepIdList.remove(i);
+            }
+        }
         if (CollectionUtils.isNotEmpty(processTaskStepIdList)) {
             processTaskStepList = processTaskMapper.getProcessTaskStepListByIdList(processTaskStepIdList);
         }
@@ -617,6 +630,11 @@ public class ProcessTaskSlaThread extends NeatLogicThread {
                 //如果时效状态为已完成，则将耗时数据插入processtask_step_sla_time表；当时效重算时，将该时效的耗时数据从processtask_step_sla_time表删除
                 if (SlaStatus.DONE.name().toLowerCase().equals(slaTimeVo.getStatus())) {
                     List<Long> processTaskStepIdList = processTaskSlaMapper.getProcessTaskStepIdListBySlaId(slaId);
+                    for (int i = processTaskStepIdList.size() - 1; i >= 0; i--) {
+                        if (processTaskService.checkStepIsInvalid(processTaskStepIdList.get(i))) {
+                            processTaskStepIdList.remove(i);
+                        }
+                    }
                     if (CollectionUtils.isNotEmpty(processTaskStepIdList)) {
                         ProcessTaskStepSlaTimeVo processTaskStepSlaTimeVo = new ProcessTaskStepSlaTimeVo();
                         processTaskStepSlaTimeVo.setProcessTaskId(processTaskVo.getId());