不合格后重送检逻辑_2

快乐的昕的电脑

2025-10-23 810818b52ac65bd701c9582571be23ded5aea776

 Services/MesOrderStaManager.cs

@@ -93,7 +93,10 @@
    /// <summary>
    ///     更新机器时间并处理首检/重送检
    /// </summary>
    /// <param name="entity">工单状态实体,包含机器时间信息（Flag：1=首次送检；2=不合格后重新送检）</param>
    /// <param name="entity">
    ///     工单状态实体,包含机器时间信息
    ///     Flag：1 = 首次送检呼叫；2 = 首检不合格后重新送检；其它值仅更新时间不触发首检单创建
    /// </param>
    /// <returns>更新是否成功</returns>
    public bool ChangeMachineTime(MesOrderSta entity)
    {
@@ -101,18 +104,20 @@
            .Where(s => s.Id == entity.OrderId).First();
        if (womdaa == null) throw new Exception("工单不存在");

        // ================== 首次送检处理（Flag == 1）==================
        if (entity.Flag == 1)
        {
            // 首次送检：幂等，避免重复生成
            // 幂等：先查是否已有未作废的首检单（避免重复生成）
            var existsFirst = Db.Queryable<MesQaItemsDetect02>()
                .Where(s => s.Aufnr == womdaa.Daa001 && s.Ftype == "首检" && (s.Fcancel == null || s.Fcancel != "Y"))
                .Any();

            if (!existsFirst)
            {
                // 行级锁防并发
                // 行级锁防并发（Oracle FOR UPDATE）
                Db.Ado.ExecuteCommand("SELECT ID FROM WOMDAA WHERE DAA001 = :BILL_NO FOR UPDATE",
                    new SugarParameter("BILL_NO", womdaa.Daa001));

                // 二次确认
                existsFirst = Db.Queryable<MesQaItemsDetect02>()
                    .Where(s => s.Aufnr == womdaa.Daa001 && s.Ftype == "首检" && (s.Fcancel == null || s.Fcancel != "Y"))
@@ -120,7 +125,7 @@

                if (!existsFirst)
                {
                    // 调用存储过程（单路径）
                    // 调用存储过程生成首检单
                    Db.Ado.ExecuteCommand(
                        "BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
                        new SugarParameter("BILL_NO", womdaa.Daa001, System.Data.DbType.String));
@@ -142,9 +147,18 @@
                    .ExecuteCommand();
            }
        }
        // ================== 不合格后重新送检（Flag == 2）==================
        else if (entity.Flag == 2)
        {
            // 不合格后重送检：仅在最新有效首检结果为“不合格”时生成新的首检单；幂等+并发控制
            // 首检不合格后直接生成新的首检单：
            // 1. 加锁防并发
            // 2. 若不存在首检 -> 直接生成
            // 3. 若存在且为“不合格” -> 先作废旧单(Fcancel='Y')再生成新单（绕过存储过程内部只允许一单的限制）
            // 4. 若已合格 -> 不生成
            Db.Ado.ExecuteCommand("SELECT ID FROM WOMDAA WHERE DAA001 = :BILL_NO FOR UPDATE",
                new SugarParameter("BILL_NO", womdaa.Daa001));

            // 最新未作废首检单
            var latestFirst = Db.Queryable<MesQaItemsDetect02>()
                .Where(s => s.Aufnr == womdaa.Daa001
                            && s.Ftype == "首检"
@@ -152,59 +166,95 @@
                .OrderBy(s => s.CreateDate, OrderByType.Desc)
                .First();

            // 满足条件：存在最新首检且判定结果为“不合格”
            if (latestFirst != null && latestFirst.FcheckResu == "不合格")
            {
                // 行级锁
                Db.Ado.ExecuteCommand("SELECT ID FROM WOMDAA WHERE DAA001 = :BILL_NO FOR UPDATE",
                    new SugarParameter("BILL_NO", womdaa.Daa001));
            var needCreate = false;

                // 二次确认（再次读取最新首检）
                latestFirst = Db.Queryable<MesQaItemsDetect02>()
            if (latestFirst == null)
            {
                // 没有任何有效首检单，需要创建
                needCreate = true;
            }
            else if (latestFirst.FcheckResu == "不合格")
            {
                // 旧单不合格，先作废再创建新单
                Db.Updateable<MesQaItemsDetect02>()
                    .SetColumns(s => s.Fcancel == "Y")
                    .Where(s => s.Id == latestFirst.Id && (s.Fcancel == null || s.Fcancel != "Y"))
                    .ExecuteCommand();
                needCreate = true;
            }

            if (needCreate)
            {
                Db.Ado.ExecuteCommand(
                    "BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
                    new SugarParameter("BILL_NO", womdaa.Daa001, System.Data.DbType.String));

                // 获取新生成的首检单并写备注
                var newLatest = Db.Queryable<MesQaItemsDetect02>()
                    .Where(s => s.Aufnr == womdaa.Daa001
                                && s.Ftype == "首检"
                                && (s.Fcancel == null || s.Fcancel != "Y"))
                    .OrderBy(s => s.CreateDate, OrderByType.Desc)
                    .First();

                if (latestFirst != null && latestFirst.FcheckResu == "不合格")
                if (newLatest != null)
                {
                    // 生成新的首检单（重新送检）
                    Db.Ado.ExecuteCommand(
                        "BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
                        new SugarParameter("BILL_NO", womdaa.Daa001, System.Data.DbType.String));

                    // 更新新生成首检单备注
                    var newLatest = Db.Queryable<MesQaItemsDetect02>()
                        .Where(s => s.Aufnr == womdaa.Daa001
                                    && s.Ftype == "首检"
                                    && (s.Fcancel == null || s.Fcancel != "Y"))
                        .OrderBy(s => s.CreateDate, OrderByType.Desc)
                        .First();

                    if (newLatest != null)
                    {
                        var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                        var remark = $"工控机于{ts}不合格重新送检生成的首检单";
                        Db.Updateable<MesQaItemsDetect02>()
                            .SetColumns(s => s.Remeke == remark)
                            .Where(s => s.Id == newLatest.Id)
                            .ExecuteCommand();
                    }
                    var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    var remark = $"工控机于{ts}不合格重新送检生成的首检单";
                    Db.Updateable<MesQaItemsDetect02>()
                        .SetColumns(s => s.Remeke == remark)
                        .Where(s => s.Id == newLatest.Id)
                        .ExecuteCommand();
                }
            }
        // 已有且合格 -> 不执行创建
        // 若最新已合格则不生成新单，直接继续后续流程（不覆盖其备注）
    }

        // ========= 首检不合格清空送检时间处理（Flag != 2 时才清空；并生成统一 remark） =========
        string remarkToSet = null;      // 最终要写入 MES_ORDER_STA.remark 的内容
        var clearMaShoutTime = false;   // 是否需要真正写 null 清空送检时间

        if (entity.Flag == 1)
        {
            // 首次送检提交
            if (!string.IsNullOrEmpty(entity.MaShoutTime))
                remarkToSet = $"于{entity.MaShoutTime}时间有一次送检";
        }
        else if (entity.Flag == 2)
        {
            // 不合格重新送检（不清空送检时间，由前端可能覆盖为新时间）
            if (!string.IsNullOrEmpty(entity.MaShoutTime))
                remarkToSet = $"于{entity.MaShoutTime}时间不合格重新送检";
        }

        // 原逻辑保持...
        // 非重新送检场景（Flag!=2）才检查是否需要因“不合格”清空送检时间
        if (entity.Flag != 2)
        {
            var latestFirstCheck = Db.Queryable<MesQaItemsDetect02>()
                .Where(s => s.Aufnr == womdaa.Daa001
                            && s.Ftype == "首检"
                            && (s.Fcancel == null || s.Fcancel != "Y"))
                .OrderBy(s => s.CreateDate, OrderByType.Desc)
                .First();

            if (latestFirstCheck != null && latestFirstCheck.FcheckResu == "不合格")
            {
                entity.MaShoutTime = null;  // 置空实体（后面更新时使用）
                clearMaShoutTime = true;
                remarkToSet = "首检不合格，送检时间已清空，请重新送检呼叫生成新的首检单";
            }
        }
        // ========= 首检不合格清空送检时间处理结束 =========

        // ================== 采集数/锚点 Anchors 处理 ==================
        var mesReporting = Db.Queryable<MesReporting>()
            .Where(s => s.BillNo == womdaa.Daa001)
            .OrderByDescending(s => s.Id)
            .First();


        var editDate = DateTime.Now.ToString("yyyy-MM-dd");

        // 发送HTTP请求到数据刷新接口
        // 发送HTTP请求刷新设备采集数据（失败不阻断后续）
        MesNumericalBycl mesNumerical = null;
        try
        {
@@ -221,16 +271,12 @@

                if (response.IsSuccessStatusCode)
                {
                    var responseString = response.Content.ReadAsStringAsync()
                        .GetAwaiter().GetResult();
                    var responseString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                    var responseObj = JsonConvert.DeserializeObject<dynamic>(responseString);

                    if (responseObj != null && responseObj.code == 200)
                    {
                        // 请求成功，获取MesNumerical数据
                        mesNumerical = Db.Queryable<MesNumericalBycl>()
                            .Where(s => s.EditDate == editDate
                                        && s.MachineNo == entity.MachineNo)
                            .Where(s => s.EditDate == editDate && s.MachineNo == entity.MachineNo)
                            .OrderByDescending(s => s.Id)
                            .First();
                    }
@@ -239,15 +285,12 @@
        }
        catch (Exception ex)
        {
            // 记录异常但不阻止流程
            Console.WriteLine($"发送数据刷新请求时出错: {ex.Message}");
        }

        // 如果请求失败或获取数据失败，mesNumerical将保持为null

        // 删除并重建当日锚点记录
        Db.Deleteable<MesAnchors>()
            .Where(a => a.EditDate == editDate
                        && a.OrderId == womdaa.Id)
            .Where(a => a.EditDate == editDate && a.OrderId == womdaa.Id)
            .ExecuteCommand();

        MesAnchors eAnchors = new MesAnchors
@@ -260,15 +303,14 @@
        };
        Db.Insertable<MesAnchors>(eAnchors).ExecuteCommand();

        // 送检合格自动调机完成与开工
        if (!string.IsNullOrEmpty(entity.MaShoutTime))
        // ================== 首检合格 -> 自动调机完成 + 写入开工时间 ==================
        if (!clearMaShoutTime && !string.IsNullOrEmpty(entity.MaShoutTime)) // 未被清空的前提下才判断合格逻辑
        {
            if (DateTime.TryParse(entity.MaShoutTime, out var sjTime) &&
                DateTime.TryParse(entity.MaStartTime, out var startTime))
            {
                if (sjTime >= startTime)
                {
                    // 查找该工单号下最新的首检单
                    var sjRecord = Db.Queryable<MesQaItemsDetect02>()
                        .Where(x => x.Aufnr == womdaa.Daa001 && x.Ftype == "首检" && (x.Fcancel == null || x.Fcancel != "Y"))
                        .OrderBy(x => x.CreateDate, OrderByType.Desc)
@@ -276,41 +318,41 @@

                    if (sjRecord != null && sjRecord.FcheckResu == "合格")
                    {
                        // 使用QualifiedInspection方法更新工单状态
                        QualifiedInspection(new OrderMachineDto
                        {
                            OrderId = entity.OrderId,
                            orderNo = entity.OrderNo,
                            machineNo = entity.MachineNo
                        });
                        //将送检时间写入开工时间
                        // 将送检时间写入开工时间
                        entity.StartTime = entity.MaShoutTime;
                        entity.MaEndTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                        // 若之前 remark 是“送检”可继续沿用；不强制覆盖
                    }
                }
            }
        }

        // 更新工单状态表
        // ================== 最终更新 MES_ORDER_STA ==================
        return Db.Updateable<MesOrderSta>()
            // 如果有送检时间则更新
            .SetColumnsIF(entity.MaShoutTime != null,
            // 送检时间更新：若需要清空则明确赋 null；否则当有值时更新
            .SetColumnsIF(clearMaShoutTime, s => s.MaShoutTime == null)
            .SetColumnsIF(!clearMaShoutTime && entity.MaShoutTime != null,
                s => s.MaShoutTime == entity.MaShoutTime)
            // 如果有调机开始时间则更新
            // 调机开始时间
            .SetColumnsIF(entity.MaStartTime != null,
                s => s.MaStartTime == entity.MaStartTime)
            // 如果有调机完成时间则更新
            // 调机完成时间
            .SetColumnsIF(entity.MaEndTime != null,
                s => s.MaEndTime == entity.MaEndTime)
            // 如果有开工时间则更新
            // 开工时间
            .SetColumnsIF(entity.StartTime != null,
                s => s.StartTime == entity.StartTime)
            // 如果标记为1则更新备注信息
            .SetColumnsIF(entity.Flag == 1,
                s => s.remark == "于" + entity.MaShoutTime + "时间有一次送检")
            // 根据ID匹配记录
            // 统一备注（由前面逻辑确定）
            .SetColumnsIF(!string.IsNullOrEmpty(remarkToSet),
                s => s.remark == remarkToSet)
            // 过滤当前记录
            .Where(s => s.Id == entity.Id)
            // 执行更新并判断影响行数是否大于0
            .ExecuteCommand() > 0;
    }