工步修改为支持并行执行行为，优化工步执行逻辑

Rodney Chen

2024-07-19 01a5cb6f77739630a88fc2f95be694b53ade0d41

 Tiger.Business.MES/Transaction/CollectNode.cs

@@ -35,18 +35,18 @@
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<ApiAction> Submit(SubmitInput input)
        public async Task<ApiAction<SubmitOutput>> Submit(SubmitInput input)
        {
            var action = new ApiAction();
            var action = new ApiAction<SubmitOutput>();
            try
            {
                //工步列表为空时，认为需要先扫描过站条码
                if (Steps.IsNullOrEmpty())
                //工步列表为空或者工序节点工步有未完成时，优先完成工序节点工步
                if (Steps.IsNullOrEmpty() || !IsFinishNodeSteps)
                {
                    //先判断当前工单不为空且当前岗位在当前工单是不是首站，如果是则不允许变更当前工单，尝试把条码绑定到当前工单
                    if (!CurBatch.IsNullOrEmpty() && CurBatch.IsFirstNode(PostCode))
                    {
                        action = ScanSn(action, input);
                        action = NodeSubmit(action, input);
                        return action;
                    }
                    //当前岗位在当前工单不是首站，则查找条码已绑定的工单当作当前工单
@@ -64,12 +64,13 @@
                                var result = await SelectOrder(new() { AuthOption = input.AuthOption, OrderNo = wosn.Batch.ORDER_NO });
                                if (!result.IsSuccessed)
                                {
                                    action = result;
                                    action.IsSuccessed = result.IsSuccessed;
                                    action.LocaleMsg = result.LocaleMsg;
                                    return action;
                                }
                            }
                            //条码过站
                            action = ScanSn(action, input);
                            action = NodeSubmit(action, input);
                            return action;
                        }
                        //查找不到条码已绑定的工单
@@ -94,22 +95,47 @@
                        }
                    }
                }
                //完成第一步，后开始执行当前工序的行为列表
                else if (Steps.First().IsFinished && !IsFinishAllSteps)
                //完成工序节点工步后，后开始执行当前工序的行为工步
                else if (IsFinishNodeSteps && !IsFinishAllSteps)
                {
                    //var curStep = Steps.Where(q => !q.IsFinished).OrderBy(q => q.Sequence).First();
                    var curStep = Steps.Where(q => q.ID == input.StepID).FirstOrDefault();
                    if (!curStep.IsNullOrEmpty())
                    var submitStep = Steps.Where(q => q.ID == input.CurStepID && !q.IsFinished).FirstOrDefault();
                    if (submitStep.IsNullOrEmpty())
                    {
                        var result = curStep.Submit(input);
                        result.Data.StepID = curStep.ID;
                        action = BeginNextActionStep(input);
                        return action;
                    }
                    else
                    {
                        var result = submitStep.Submit(input);
                        //如果当前工步已完成，开始执行下一工步
                        if (result.IsSuccessed && submitStep.IsFinished)
                        {
                            result = BeginNextActionStep(input);
                        }
                        //如果当前工步未完成
                        else
                        {
                            //行为执行出错，工步被重置
                            if (Steps.IsNullOrEmpty())
                            {
                                result.LocaleMsg = new(Biz.T(result.LocaleMsg, input.Locale) + Biz.T(Biz.L("MES.Transaction.Position.RescanSN"), input.Locale));
                            }
                            else
                            {
                        result.Data.IsFinished = IsFinishAllSteps;
                        result.Data.CurStep = CurStep;
                                result.Data.CurWO = CurBatch.WO.ORDER_NO;
                                result.Data.CurBatch = CurBatch.Batch.BATCH_NO;
                                result.Data.CurNode = CurStep.NodeAct.ACT_NAME;
                                result.Data.StepActCode = CurStep.NodeAct.ACT_CODE;
                                result.Data.NextStepID = CurStep.ID;
                            }
                        }
                        //如果所有工步都完成
                        if (IsFinishAllSteps)
                        {
                            return DoIfFinishAllSteps(result.ToApiAction());
                            return DoIfFinishAllSteps(result);
                        }
                        return result.ToApiAction();
                        return result;
                    }
                }
                //没有可执行的工步
@@ -126,14 +152,17 @@
        }

        /// <summary>
        /// 扫描过站条码
        /// 工序节点工步提交数据
        /// </summary>
        /// <param name="action"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        public ApiAction ScanSn(ApiAction action, SubmitInput input)
        public ApiAction<SubmitOutput> NodeSubmit(ApiAction<SubmitOutput> action, SubmitInput input)
        {
            try
            {
                //当工步列表为空，则执行当前工序的必要逻辑当作第一个工序节点，完成后按需求创建后续的工步列表
                if (Steps.IsNullOrEmpty())
            {
                //绑定条码到工单
                if (!CurBatch.WoSNs.Any(q => q.SN == input.SN))
@@ -208,8 +237,9 @@

                //初始化工步列表
                Steps.Clear();
                var curStep = new Biz.WorkStep(curNode.ID, IWorkStep.Types.Node)
                    var curStep = new Biz.WorkStep(IWorkStep.Types.Node, this)
                {
                        NodeID = curNode.ID,
                    Sequence = Steps.Count + 1,
                    Node = curNode,
                    DBSubmitAction = () =>
@@ -222,34 +252,68 @@
                };
                Steps.Add(curStep);

                //如果当前工序节点有行为则添加到工步列表
                var acts = CurBatch.NodeActs.Where(q => q.NODE_ID == curNode.ID).ToList();
                foreach (var act in acts)
                    //有需要则添加工序节点的其他工步

                    //最后添加当前工序的行为工步
                    GenerateSteps(curStep);

                    //完成第一个工序节点工步
                    curStep.IsFinished = true;
                    CurStep = curStep;
                }
                else if (!IsFinishNodeSteps)
                {
                    Steps.Add(new Biz.WorkStep(act.ID, IWorkStep.Types.Action)
                    {
                        Sequence = Steps.Count + 1,
                        Node = curNode,
                        NodeAct = act,
                        Setting = CurBatch.ActionSets.FirstOrDefault(q => q.ACT_ID == act.ID),
                    });
                    var curStep = Steps.Where(q => q.Type == IWorkStep.Types.Node && !q.IsFinished).OrderBy(q => q.Sequence).First();

                    //完成当前工序节点工步
                    curStep.IsFinished = true;
                    CurStep = curStep;
                }

                //完成当前工序节点
                curStep.IsFinished = true;
                //未完成所有工步
                if (!IsFinishAllSteps)
                {
                    var next = Steps.Where(q => !q.IsFinished).OrderBy(q => q.Sequence).First();
                    var result = next.Begin(this);
                    result.Data.StepID = next.ID;
                    var result = new ApiAction<SubmitOutput>();
                    //未完成所有工序节点工步
                    if (!IsFinishNodeSteps)
                    {
                        var next = Steps.Where(q => q.Type == IWorkStep.Types.Node && !q.IsFinished).OrderBy(q => q.Sequence).First();
                        //设置后续可执行的工步列表
                        NextSteps.Clear();
                        NextSteps.Add(next);
                        //根据后续工步返回ApiAction
                    result.Data.IsFinished = IsFinishAllSteps;
                    result.Data.CurStep = CurStep;
                    return result.ToApiAction();
                        result.Data.CurWO = CurBatch.WO.ORDER_NO;
                        result.Data.CurBatch = CurBatch.Batch.BATCH_NO;
                        result.Data.CurNode = CurStep.Node.NODE_NAME;
                        result.Data.NextStepID = next.ID;

                        //根据工序节点工步的序号返回相应的操作提示
                        switch (next.Sequence)
                        {
                            case 2:
                                //action.LocaleMsg = new($"请执行第二步");
                                result.LocaleMsg = new("MES.Transaction.CollectNode.第二步操作提示");
                                break;
                            default:
                                break;
                        }
                    }
                    //已完成所有工序节点工步，开始执行行为工步
                    else
                    {
                        result = BeginNextActionStep(input);
                    }
                    return result;
                }
                //已完成所有工步
                else
                {
                    action.Data.IsFinished = IsFinishAllSteps;
                    action.Data.CurWO = CurBatch.WO.ORDER_NO;
                    action.Data.CurBatch = CurBatch.Batch.BATCH_NO;
                    action.Data.CurNode = CurStep.Node.NODE_NAME;
                    action.Data.NextStepID = "";
                    action = DoIfFinishAllSteps(action);
                }
            }
@@ -266,7 +330,7 @@
        /// </summary>
        /// <param name="action"></param>
        /// <returns></returns>
        public ApiAction DoIfFinishAllSteps(ApiAction action)
        public ApiAction<SubmitOutput> DoIfFinishAllSteps(ApiAction<SubmitOutput> action)
        {
            //保存数据库
            var dbTran = GetCommitDB().UseTran(() =>