存储过程未生成 → 兜底 C# 自动生成

快乐的昕的电脑

2025-11-18 62922f98de63b19f54c12a6ad8b39d61b62011ed

 Services/MesOrderStaManager.cs

@@ -91,108 +91,284 @@
    }

    /// <summary>
    ///     更新机器时间并处理首检
    ///     变更说明：
    ///     1) 最新首检结果为“不合格”时：只清空 MA_SHOUT_TIME（送检呼叫时间），不重建首检单
    ///     2) 若不存在首检单时：允许创建（重建）首检单
    ///     3) 首检合格且送检时间 >= 调机开始时间时：写入调机完成时间与开工时间
    ///     更新机器时间并处理首检/重送检
    /// </summary>
    /// <param name="entity">
    ///     工单状态实体,包含机器时间信息
    ///     Flag：1 = 首次送检呼叫；2 = 首检不合格后重新送检；其它值仅更新时间不触发首检单创建
    /// </param>
    /// <returns>更新是否成功</returns>
    public bool ChangeMachineTime(MesOrderSta entity)
    {
        const string FirstCheckType = "首检";
        const string FirstCheckResultOK = "合格";
        const string FirstCheckResultNG = "不合格";

        var womdaa = Db.Queryable<Womdaa>()
            .Where(s => s.Id == entity.OrderId).First();
        if (womdaa == null) throw new Exception("工单不存在");

        MesQaItemsDetect02 latestFirst = null;
        var clearMaShout = false;

        // 原来限制 entity.Flag == 1，这里取消限制：任何保存动作都评估首检结果
        // 行级锁防并发
        Db.Ado.ExecuteCommand("SELECT ID FROM WOMDAA WHERE DAA001 = :BILL_NO FOR UPDATE",
            new SugarParameter("BILL_NO", womdaa.Daa001));

        // 当前最新首检
        latestFirst = Db.Queryable<MesQaItemsDetect02>()
            .Where(s => s.Aufnr == womdaa.Daa001 && s.Ftype == FirstCheckType && (s.Fcancel == null || s.Fcancel != "Y"))
            .OrderBy(s => s.CreateDate, OrderByType.Desc)
            .First();

        // 结果归一（防止尾部空格或大小写）：可能来源于接口/用户录入
        var latestResult = latestFirst?.FcheckResu?.Trim();

        // 仅在不存在首检单时创建
        if (latestFirst == null)
        // ================== 首次送检处理（Flag == 1）==================
        if (entity.Flag == 1)
        {
            Db.Ado.ExecuteCommand(
                "BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
                new SugarParameter("BILL_NO", womdaa.Daa001, System.Data.DbType.String));
            // 幂等：先查是否已有未作废的首检单（避免重复生成）
            var existsFirst = Db.Queryable<MesQaItemsDetect02>()
                .Where(s => s.Aufnr == womdaa.Daa001 && s.Ftype == "首检" && (s.Fcancel == null || s.Fcancel != "Y"))
                .Any();

            latestFirst = Db.Queryable<MesQaItemsDetect02>()
                .Where(s => s.Aufnr == womdaa.Daa001 && s.Ftype == FirstCheckType && (s.Fcancel == null || s.Fcancel != "Y"))
            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"))
                    .Any();

                if (!existsFirst)
                {
                    // 调用存储过程生成首检单
                    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();

                // 存储过程未生成 → 兜底 C# 自动生成
                if (newLatest == null)
                {
                    Console.WriteLine("[重送检] 存储过程未生成，执行 C# 兜底逻辑");
                    var fallback = mesQaItemsDetect02Manager.AutomaticIpqcFirstCheck(womdaa.Daa001);
                    if (fallback)
                    {
                        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();
                    }
                }

            }

            // 统一更新最新首检备注
            var latestFirst = 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)
            {
                var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                var remark = $"工控机于{ts}自动创建的首检单";
                Db.Updateable<MesQaItemsDetect02>()
                    .SetColumns(s => s.Remeke == $"工控机于{ts}自动创建的首检单(首次创建)")
                    .SetColumns(s => s.Remeke == remark)
                    .Where(s => s.Id == latestFirst.Id)
                    .ExecuteCommand();
            }
        }
        else
        // ================== 不合格后重新送检（Flag == 2）==================
        else if (entity.Flag == 2)
        {
            // 最新结果为“不合格” => 清空送检时间，不重建
            if (string.Equals(latestResult, FirstCheckResultNG, StringComparison.OrdinalIgnoreCase))
            // 1.加锁防并发（行级锁）
            Db.Ado.ExecuteCommand(
                "SELECT ID FROM WOMDAA WHERE DAA001 = :BILL_NO FOR UPDATE",
                new SugarParameter("BILL_NO", womdaa.Daa001));

            // 2. 当前最新未作废首检单
            var latestFirst = Db.Queryable<MesQaItemsDetect02>()
                .Where(s => s.Aufnr == womdaa.Daa001
                            && s.Ftype == "首检"
                            && (s.Fcancel == null || s.Fcancel != "Y"))
                .OrderBy(s => s.CreateDate, OrderByType.Desc)
                .First();

            bool needReCreate = false;
            /*
             3. 判断是否需要重新生成首检单
•   如果最新首检单存在且结果为“不合格”或“NG”，则需要重建首检单。
•   如果没有活动首检单，但存在已作废的不合格首检记录，也允许重建。
             */
            if (latestFirst != null)
            {
                clearMaShout = true;
                entity.MaShoutTime = null;
                entity.remark = $"最新首检结果“{FirstCheckResultNG}”，已清空送检时间，待再次送检";
                var resu = latestFirst.FcheckResu?.Trim();
                if (!string.IsNullOrEmpty(resu) &&
                    (resu == "不合格" || resu.Equals("NG", StringComparison.OrdinalIgnoreCase)))
                {
                    needReCreate = true;
                }
            }
            else
            {
                // 其它结果更新备注
                // 4. 没有活动首检单，判断是否存在已作废的不合格首检记录
                var existsCanceledNg = Db.Queryable<MesQaItemsDetect02>()
                    .Where(s => s.Aufnr == womdaa.Daa001
                                && s.Ftype == "首检"
                                && s.Fcancel == "Y"
                                && (s.FcheckResu == "不合格" || s.FcheckResu == "NG"))
                    .Any();
                if (existsCanceledNg)
                {
                    needReCreate = true;
                    Console.WriteLine("[重送检] 无活动首检单但存在作废的不合格记录，允许重建");
                }
            }

            if (needReCreate)
            {
                // 作废当前活动不合格单
                if (latestFirst != null)
                {
                    Db.Updateable<MesQaItemsDetect02>()
                        .SetColumns(s => s.Fcancel == "Y")
                        .Where(s => s.Id == latestFirst.Id
                                    && (s.Fcancel == null || s.Fcancel != "Y"))
                        .ExecuteCommand();
                }

                bool procOk = true;
                string procErr = "";
                try
                {
                    // 5. 调用存储过程生成新首检单
                    Db.Ado.ExecuteCommand(
                        "BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
                        new SugarParameter("BILL_NO", womdaa.Daa001, System.Data.DbType.String));
                }
                catch (Exception ex)
                {
                    procOk = false;
                    procErr = ex.Message;
                    Console.WriteLine($"[重送检] 存储过程异常: {procErr}");
                }

                // 再次查询新生成的首检单
                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();

                // 存储过程未生成 → 兜底 C# 自动生成
                if (newLatest == null)
                {
                    Console.WriteLine("[重送检] 存储过程未生成，执行 C# 兜底逻辑");
                    var fallback = mesQaItemsDetect02Manager.AutomaticIpqcFirstCheck(womdaa.Daa001);
                    if (fallback)
                    {
                        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();
                    }
                }

                //6. 新首检单生成后，写入备注

                var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                Db.Updateable<MesQaItemsDetect02>()
                    .SetColumns(s => s.Remeke == $"工控机于{ts}首检结果：{latestResult}")
                    .Where(s => s.Id == latestFirst.Id)
                    .ExecuteCommand();
                //只有开工状态下可以暂停工单
                //当首检结果为‘合格’、‘不合格’时，更新备注
                if (newLatest != null && newLatest.FcheckResu == "合格")
                {
                    var remark = $"工控机于{ts}取消暂停重新送检生成的首检单";
                    Db.Updateable<MesQaItemsDetect02>()
                        .SetColumns(s => s.Remeke == remark)
                        .Where(s => s.Id == newLatest.Id)
                        .ExecuteCommand();
                }
                else if (newLatest != null && newLatest.FcheckResu == "不合格")
                {
                    var remark = $"工控机于{ts}不合格重新送检生成的首检单";
                    Db.Updateable<MesQaItemsDetect02>()
                        .SetColumns(s => s.Remeke == remark)
                        .Where(s => s.Id == newLatest.Id)
                        .ExecuteCommand();
                }
                else
                {
                    Console.WriteLine("[重送检] 仍未生成新首检单，请检查存储过程计数是否排除作废单。");
                }
            }
        }

        // 后续逻辑保持
        // ========= 首检不合格清空送检时间处理（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请求刷新设备采集数据（失败不阻断后续）
        MesNumericalBycl mesNumerical = null;
        try
        {
            using var httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
            var content = new StringContent(
                JsonConvert.SerializeObject(new { machineNo = entity.MachineNo }),
                Encoding.UTF8, "application/json");

            var response = httpClient.PostAsync("http://192.168.0.94:9095/Numerical/RefreshDevBycl", content)
                .GetAwaiter().GetResult();

            if (response.IsSuccessStatusCode)
            using (var httpClient = new HttpClient())
            {
                var responseString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                var responseObj = JsonConvert.DeserializeObject<dynamic>(responseString);
                if (responseObj != null && responseObj.code == 200)
                httpClient.Timeout = TimeSpan.FromSeconds(30);
                var content = new StringContent(
                    JsonConvert.SerializeObject(new { machineNo = entity.MachineNo }),
                    Encoding.UTF8,
                    "application/json");
                var response = httpClient
                    .PostAsync("http://192.168.0.94:9095/Numerical/RefreshDevBycl", content)
                    .GetAwaiter().GetResult();

                if (response.IsSuccessStatusCode)
                {
                    mesNumerical = Db.Queryable<MesNumericalBycl>()
                        .Where(s => s.EditDate == editDate && s.MachineNo == entity.MachineNo)
                        .OrderByDescending(s => s.Id)
                        .First();
                    var responseString = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                    var responseObj = JsonConvert.DeserializeObject<dynamic>(responseString);
                    if (responseObj != null && responseObj.code == 200)
                    {
                        mesNumerical = Db.Queryable<MesNumericalBycl>()
                            .Where(s => s.EditDate == editDate && s.MachineNo == entity.MachineNo)
                            .OrderByDescending(s => s.Id)
                            .First();
                    }
                }
            }
        }
@@ -201,11 +377,12 @@
            Console.WriteLine($"发送数据刷新请求时出错: {ex.Message}");
        }

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

        var eAnchors = new MesAnchors
        MesAnchors eAnchors = new MesAnchors
        {
            OrderId = womdaa.Id,
            OrderNo = womdaa.Daa001,
@@ -215,43 +392,57 @@
        };
        Db.Insertable<MesAnchors>(eAnchors).ExecuteCommand();

        // 若送检时间存在且最新首检合格 => 写调机完成与开工时间
        if (!clearMaShout && !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) &&
                sjTime >= startTime)
                DateTime.TryParse(entity.MaStartTime, out var startTime))
            {
                var sjRecord = latestFirst ??
                               Db.Queryable<MesQaItemsDetect02>()
                                   .Where(x => x.Aufnr == womdaa.Daa001 && x.Ftype == FirstCheckType && (x.Fcancel == null || x.Fcancel != "Y"))
                                   .OrderBy(x => x.CreateDate, OrderByType.Desc)
                                   .First();

                if (sjRecord != null && string.Equals(sjRecord.FcheckResu?.Trim(), FirstCheckResultOK, StringComparison.OrdinalIgnoreCase))
                if (sjTime >= startTime)
                {
                    QualifiedInspection(new OrderMachineDto
                    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)
                        .First();

                    if (sjRecord != null && sjRecord.FcheckResu == "合格")
                    {
                        OrderId = entity.OrderId,
                        orderNo = entity.OrderNo,
                        machineNo = entity.MachineNo
                    });
                    entity.StartTime = entity.MaShoutTime;
                    entity.MaEndTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                        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 是“送检”可继续沿用；不强制覆盖
                    }
                }
            }
        }

        var upd = Db.Updateable<MesOrderSta>()
            .SetColumnsIF(clearMaShout, s => s.MaShoutTime == null)
            .SetColumnsIF(!clearMaShout && 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)
            .SetColumnsIF(entity.Flag == 1 && entity.remark != null, s => s.remark == entity.remark)
            .Where(s => s.Id == entity.Id);

        return upd.ExecuteCommand() > 0;
        // ================== 最终更新 MES_ORDER_STA ==================
        return Db.Updateable<MesOrderSta>()
            // 送检时间更新：若需要清空则明确赋 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)
            // 统一备注（由前面逻辑确定）
            .SetColumnsIF(!string.IsNullOrEmpty(remarkToSet),
                s => s.remark == remarkToSet)
            // 过滤当前记录
            .Where(s => s.Id == entity.Id)
            .ExecuteCommand() > 0;
    }

    /// <summary>
@@ -404,125 +595,125 @@

                    break;
                case "完工":
                {
                    // 更新工单选择表显示状态
                    // Db.Updateable<MesOrderSelect>()
                    //     .SetColumns(a => a.IsShow == 1)
                    //     .Where(a => orderIds.Contains(a.OrderId))
                    //     .ExecuteCommand();

                    // 更新工单状态表
                    // Db.Updateable<MesOrderSta>()
                    //     .SetColumns(a => a.IsShow == 0)
                    //     .SetColumns(a => a.EndTime == endDate)
                    //     .Where(a => orderIds.Contains(a.OrderId))
                    //     .ExecuteCommand();

                    // 处理每个工单的报工数据
                    foreach (var orderId in orderIds)
                    {
                        // 查询工单主表信息
                        var womdaa = Db.Queryable<Womdaa>()
                            .Where(s => s.Id == orderId).First();
                        // 更新工单选择表显示状态
                        // Db.Updateable<MesOrderSelect>()
                        //     .SetColumns(a => a.IsShow == 1)
                        //     .Where(a => orderIds.Contains(a.OrderId))
                        //     .ExecuteCommand();

                        //当已生成数不等于完工数是就跳过
                        if (womdaa.Daa008 > womdaa.Daa011)
                        // 更新工单状态表
                        // Db.Updateable<MesOrderSta>()
                        //     .SetColumns(a => a.IsShow == 0)
                        //     .SetColumns(a => a.EndTime == endDate)
                        //     .Where(a => orderIds.Contains(a.OrderId))
                        //     .ExecuteCommand();

                        // 处理每个工单的报工数据
                        foreach (var orderId in orderIds)
                        {
                            updateable += 1;
                            continue;
                            // 查询工单主表信息
                            var womdaa = Db.Queryable<Womdaa>()
                                .Where(s => s.Id == orderId).First();

                            //当已生成数不等于完工数是就跳过
                            if (womdaa.Daa008 > womdaa.Daa011)
                            {
                                updateable += 1;
                                continue;
                            }

                            var btnLog = new MesWorkorderBtnLog
                            {
                                WorkNo = womdaa.Daa001,
                                BtnType = "工控自动完工",
                                BtnDate = DateTime.Now
                            };
                            db.Insertable<MesWorkorderBtnLog>(btnLog)
                                .ExecuteCommand();

                            // 更新工单主表状态 - 这里将Womdaa表的daa018更新为完工状态
                            updateable = db.Updateable<Womdaa>()
                                .SetColumns(s => s.Daa018 == daa018)
                                .SetColumnsIF("完工".Equals(daa018),
                                    s => s.Daa017 == DateTime.Now)
                                .SetColumnsIF("暂停".Equals(daa018),
                                    s => s.Daa034 == DateTime.Now)
                                .Where(s => s.Id == orderId).ExecuteCommand();

                            // Db.Deleteable<MesOrderSelect>()
                            //     .Where(a =>  a.OrderId == orderId)
                            //     .ExecuteCommand();
                            //
                            // Db.Deleteable<MesOrderSta>()
                            //     .Where(a => a.OrderId == orderId)
                            //     .ExecuteCommand();
                            //更新工单选择表显示状态
                            db.Updateable<MesOrderSelect>()
                                .SetColumns(a => a.IsShow == 1)
                                .Where(a => a.OrderId == orderId)
                                .ExecuteCommand();

                            //更新工单状态表
                            db.Updateable<MesOrderSta>()
                                .SetColumns(a => a.IsShow == 0)
                                .SetColumns(a => a.EndTime == endDate)
                                .Where(a => a.OrderId == orderId)
                                .ExecuteCommand();

                            // 查询已报工数量
                            var reporting = db.Queryable<MesReporting>()
                                .Where(s => s.BillNo == womdaa.Daa001)
                                .Select(s => new MesReporting
                                {
                                    OkQty = SqlFunc.AggregateSum(s.OkQty),
                                    BfQty = SqlFunc.AggregateSum(s.BfQty)
                                }).First();

                            reporting.OkQty ??= 0;
                            reporting.BfQty ??= 0;

                            // 查询工单视图信息
                            // var vOrder = db.Queryable<VOrder>()
                            //     .Where(s => s.ID == orderId).First();

                            // 计算待报工数量
                            // var reportingOkQty =
                            //     Convert.ToDecimal(vOrder.todayOutput) -
                            //     reporting.OkQty;
                            var CjQty = Db.Queryable<MesNumericalBycl>()
                                .Where(s => s.MachineNo == entity.MachineNo && s.EditDate == date)
                                .OrderByDescending(s => s.CjTiem)
                                .Select<long?>(s => s.CjNum).First();

                            // 计算待报工数量
                            var reportingOkQty = CjQty - reporting.OkQty;

                            // 如果有待报工数量则创建报工记录
                            if (!(reportingOkQty > 0)) continue;
                            var mesReporting = new MesReporting
                            {
                                CheckType = 1,
                                BgDate = DateTime.Now,
                                AddressCode = womdaa.AddressCode,
                                MachineNo = womdaa.MachineNo,
                                // BfQty = reportingOkQty,
                                BfQty = 0,
                                BlQty = reportingOkQty,
                                OkQty = 0,
                                ItemNo = womdaa.Daa002,
                                BillNo = womdaa.Daa001,
                                CjQty = CjQty,
                                DyQty = reporting.OkQty
                            };

                            // 插入报工记录
                            db.Insertable(mesReporting)
                                .IgnoreColumns(true).ExecuteCommand();
                        }

                        var btnLog = new MesWorkorderBtnLog
                        {
                            WorkNo = womdaa.Daa001,
                            BtnType = "工控自动完工",
                            BtnDate = DateTime.Now
                        };
                        db.Insertable<MesWorkorderBtnLog>(btnLog)
                            .ExecuteCommand();

                        // 更新工单主表状态 - 这里将Womdaa表的daa018更新为完工状态
                        updateable = db.Updateable<Womdaa>()
                            .SetColumns(s => s.Daa018 == daa018)
                            .SetColumnsIF("完工".Equals(daa018),
                                s => s.Daa017 == DateTime.Now)
                            .SetColumnsIF("暂停".Equals(daa018),
                                s => s.Daa034 == DateTime.Now)
                            .Where(s => s.Id == orderId).ExecuteCommand();

                        // Db.Deleteable<MesOrderSelect>()
                        //     .Where(a =>  a.OrderId == orderId)
                        //     .ExecuteCommand();
                        //
                        // Db.Deleteable<MesOrderSta>()
                        //     .Where(a => a.OrderId == orderId)
                        //     .ExecuteCommand();
                        //更新工单选择表显示状态
                        db.Updateable<MesOrderSelect>()
                            .SetColumns(a => a.IsShow == 1)
                            .Where(a => a.OrderId == orderId)
                            .ExecuteCommand();

                        //更新工单状态表
                        db.Updateable<MesOrderSta>()
                            .SetColumns(a => a.IsShow == 0)
                            .SetColumns(a => a.EndTime == endDate)
                            .Where(a => a.OrderId == orderId)
                            .ExecuteCommand();

                        // 查询已报工数量
                        var reporting = db.Queryable<MesReporting>()
                            .Where(s => s.BillNo == womdaa.Daa001)
                            .Select(s => new MesReporting
                            {
                                OkQty = SqlFunc.AggregateSum(s.OkQty),
                                BfQty = SqlFunc.AggregateSum(s.BfQty)
                            }).First();
                        
                        reporting.OkQty ??= 0;
                        reporting.BfQty ??= 0;
                        
                        // 查询工单视图信息
                        // var vOrder = db.Queryable<VOrder>()
                        //     .Where(s => s.ID == orderId).First();
                        
                        // 计算待报工数量
                        // var reportingOkQty =
                        //     Convert.ToDecimal(vOrder.todayOutput) -
                        //     reporting.OkQty;
                        var CjQty = Db.Queryable<MesNumericalBycl>()
                            .Where(s => s.MachineNo == entity.MachineNo && s.EditDate == date)
                            .OrderByDescending(s=>s.CjTiem)
                            .Select<long?>(s=>s.CjNum).First();
                        
                        // 计算待报工数量
                        var reportingOkQty = CjQty - reporting.OkQty;
                        
                        // 如果有待报工数量则创建报工记录
                        if (!(reportingOkQty > 0)) continue;
                        var mesReporting = new MesReporting
                        {
                            CheckType = 1,
                            BgDate = DateTime.Now,
                            AddressCode = womdaa.AddressCode,
                            MachineNo = womdaa.MachineNo,
                            // BfQty = reportingOkQty,
                            BfQty = 0,
                            BlQty = reportingOkQty,
                            OkQty = 0,
                            ItemNo = womdaa.Daa002,
                            BillNo = womdaa.Daa001,
                            CjQty = CjQty,
                            DyQty = reporting.OkQty
                        };
                        
                        // 插入报工记录
                        db.Insertable(mesReporting)
                            .IgnoreColumns(true).ExecuteCommand();
                        break;
                    }

                    break;
                }
            }