1111

tjx

2025-11-05 30ecd82c14c5b62bf5444f29edcbb7a044653b93

 Services/MesOrderStaManager.cs

@@ -91,11 +91,13 @@
    }

    /// <summary>
    ///     更新机器时间并处理首检
    ///     变更说明：
    ///     1) 最新首检结果为“不合格”时：只清空 MA_SHOUT_TIME（送检呼叫时间），不重建首检单
    ///     2) 若不存在首检单时：允许创建（重建）首检单
    ///     3) 首检合格且送检时间 >= 调机开始时间时：写入调机完成时间与开工时间
    /// 调机送检逻辑重写版
    /// 流程：
    /// 1. 调机开始：只写入调机开始时间(MA_START_TIME)
    /// 2. 送检呼叫：写入调机开始时间(若未写)与送检时间(MA_SHOUT_TIME)，并创建首检单
    /// 3. 调机完成：保持原逻辑，首检合格后写入开工(START_TIME)与调机完成(MA_END_TIME)
    /// 4. 若最新首检结果为“不合格”，清空送检时间(MA_SHOUT_TIME)，提示重新送检，不立即重建
    ///    用户再次点击送检呼叫才创建新的首检单
    /// </summary>
    public bool ChangeMachineTime(MesOrderSta entity)
    {
@@ -103,160 +105,131 @@
        const string FirstCheckResultOK = "合格";
        const string FirstCheckResultNG = "不合格";

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

        MesQaItemsDetect02 latestFirst = null;
        var clearMaShout = false; // 标记：是否需要清空送检时间
        // 当前数据库状态快照
        var dbSta = Db.Queryable<MesOrderSta>().Where(s => s.Id == entity.Id).First();
        if (dbSta == null) throw new Exception("工单状态不存在");

        if (entity.Flag == 1)
        // 行级锁，保证创建首检单的并发安全
        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 == FirstCheckType
                        && (s.Fcancel == null || s.Fcancel != "Y"))
            .OrderBy(s => s.CreateDate, OrderByType.Desc)
            .First();
        var latestResult = latestFirst?.FcheckResu?.Trim();

        // 判定操作类型
        var hasStartTimeInput = !string.IsNullOrWhiteSpace(entity.MaStartTime);
        var hasShoutTimeInput = !string.IsNullOrWhiteSpace(entity.MaShoutTime);
        // 仅开始：有开始时间，送检时间为空
        var isStartOnly = hasStartTimeInput && !hasShoutTimeInput && dbSta.MaStartTime != entity.MaStartTime;
        // 送检呼叫：有送检时间（可能同时第一次写入开始时间）
        var isShoutCall = hasShoutTimeInput && dbSta.MaShoutTime != entity.MaShoutTime;
        // 完成逻辑保持：后面通过首检合格条件判断

        // 4) 若最新判定结果“不合格”，清空送检时间，提示需重新呼叫，不创建新单
        if (string.Equals(latestResult, FirstCheckResultNG, StringComparison.OrdinalIgnoreCase))
        {
            // 行级锁防并发
            Db.Ado.ExecuteCommand("SELECT ID FROM WOMDAA WHERE DAA001 = :BILL_NO FOR UPDATE",
                new SugarParameter("BILL_NO", womdaa.Daa001));
            // 清空送检时间（数据库与返回实体）
            entity.MaShoutTime = null;
            entity.remark = "首检不合格，送检时间已清空，请重新送检呼叫生成新的首检单";
            return Db.Updateable<MesOrderSta>()
                .SetColumns(s => s.MaShoutTime == null)
                .SetColumnsIF(hasStartTimeInput && dbSta.MaStartTime != entity.MaStartTime,
                    s => s.MaStartTime == entity.MaStartTime) // 允许同时写入新的开始时间（如果刚修改）
                .SetColumnsIF(entity.remark != null, s => s.remark == entity.remark)
                .Where(s => s.Id == entity.Id)
                .ExecuteCommand() > 0;
        }

            // 当前最新首检
        // 1) 调机开始：只写开始时间
        if (isStartOnly)
        {
            return Db.Updateable<MesOrderSta>()
                .SetColumns(s => s.MaStartTime == entity.MaStartTime)
                .Where(s => s.Id == entity.Id)
                .ExecuteCommand() > 0;
        }

        // 2) 送检呼叫：写入开始时间(若未写) + 送检时间，并创建首检单
        if (isShoutCall)
        {
            // 若数据库尚无开始时间，补写
            var needWriteStart = string.IsNullOrWhiteSpace(dbSta.MaStartTime) && hasStartTimeInput;

            // 创建首检单（始终按送检呼叫生成一张新的，如果需要作废旧单可加取消逻辑）
            Db.Ado.ExecuteCommand(
                "BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
                new SugarParameter("BILL_NO", womdaa.Daa001, System.Data.DbType.String));

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

            // 仅在不存在首检单时创建（原“ 不合适 ”已统一改为“ 不合格 ”，且不合格不再触发重建）
            var needCreate = latestFirst == null;

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

                // 重新获取最新首检单
                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();

                if (latestFirst != null)
                {
                    var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    Db.Updateable<MesQaItemsDetect02>()
                        .SetColumns(s => s.Remeke == $"工控机于{ts}自动创建的首检单(首次创建)")
                        .Where(s => s.Id == latestFirst.Id)
                        .ExecuteCommand();
                }
                var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                Db.Updateable<MesQaItemsDetect02>()
                    .SetColumns(s => s.Remeke == $"工控机于{ts}调机送检生成首检单")
                    .Where(s => s.Id == latestFirst.Id)
                    .ExecuteCommand();
            }
            else
            {
                // 最新结果为“不合格” => 仅清空送检时间，不重建
                if (latestFirst != null && latestFirst.FcheckResu == FirstCheckResultNG)
                {
                    clearMaShout = true;
                    entity.MaShoutTime = null;
                    entity.remark = $"最新首检结果“{FirstCheckResultNG}”，已清空送检时间，待再次送检";
                }
                else if (latestFirst != null)
                {
                    // 其它结果（如合格）更新备注
                    var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    Db.Updateable<MesQaItemsDetect02>()
                        .SetColumns(s => s.Remeke == $"工控机于{ts}首检结果：{latestFirst.FcheckResu}")
                        .Where(s => s.Id == latestFirst.Id)
                        .ExecuteCommand();
                }
            }

            entity.remark = "已生成首检单，等待检验";
            var updateCount = Db.Updateable<MesOrderSta>()
                .SetColumns(s => s.MaShoutTime == entity.MaShoutTime)
                .SetColumnsIF(needWriteStart, s => s.MaStartTime == entity.MaStartTime)
                .SetColumns(s => s.remark == entity.remark)
                .Where(s => s.Id == entity.Id)
                .ExecuteCommand();

            return updateCount > 0;
        }

        // 原报工/数采锚点逻辑保持
        var mesReporting = Db.Queryable<MesReporting>()
            .Where(s => s.BillNo == womdaa.Daa001)
            .OrderByDescending(s => s.Id)
            .First();

        var editDate = DateTime.Now.ToString("yyyy-MM-dd");
        MesNumericalBycl mesNumerical = null;
        try
        // 3) 保留调机完成逻辑：首检合格且送检时间 >= 调机开始时间时自动写开工与调机完成
        // （此处与原逻辑一致：前端不直接点“调机完成”，而是由合格触发）
        if (!string.IsNullOrEmpty(entity.MaShoutTime)
            && DateTime.TryParse(entity.MaShoutTime, out var shoutTime)
            && DateTime.TryParse(dbSta.MaStartTime ?? entity.MaStartTime, out var startTime)
            && shoutTime >= startTime
            && latestFirst != null
            && string.Equals(latestFirst.FcheckResu?.Trim(), FirstCheckResultOK, StringComparison.OrdinalIgnoreCase))
        {
            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)
            // 写开工及调机完成
            QualifiedInspection(new OrderMachineDto
            {
                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();
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"发送数据刷新请求时出错: {ex.Message}");
                OrderId = entity.OrderId,
                orderNo = entity.OrderNo,
                machineNo = entity.MachineNo
            });

            entity.StartTime = entity.MaShoutTime;
            entity.MaEndTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            return Db.Updateable<MesOrderSta>()
                .SetColumnsIF(entity.MaEndTime != null, s => s.MaEndTime == entity.MaEndTime)
                .SetColumnsIF(entity.StartTime != null, s => s.StartTime == entity.StartTime)
                .Where(s => s.Id == entity.Id)
                .ExecuteCommand() > 0;
        }

        Db.Deleteable<MesAnchors>()
            .Where(a => a.EditDate == editDate && a.OrderId == womdaa.Id)
            .ExecuteCommand();

        var eAnchors = new MesAnchors
        {
            OrderId = womdaa.Id,
            OrderNo = womdaa.Daa001,
            EditDate = editDate,
            Qty = mesReporting == null ? 0 : (long?)(mesReporting.DyQty ?? 0),
            InitialValue = mesNumerical == null ? 0 : mesNumerical.CjNum
        };
        Db.Insertable<MesAnchors>(eAnchors).ExecuteCommand();

        // 若送检时间存在且最新首检合格 => 写调机完成与开工时间
        if (!clearMaShout && !string.IsNullOrEmpty(entity.MaShoutTime))
        {
            if (DateTime.TryParse(entity.MaShoutTime, out var sjTime) &&
                DateTime.TryParse(entity.MaStartTime, out var startTime) &&
                sjTime >= 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 && sjRecord.FcheckResu == FirstCheckResultOK)
                {
                    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");
                }
            }
        }

        // 更新工单状态表
        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;
        // 若本次调用未匹配任何操作（可能只是重复提交），保持不变
        return true;
    }


    /// <summary>
    ///     初始化工单状态
    /// </summary>