调试

快乐的昕的电脑

2025-10-22 79c96c1075bfa4fc3d631c0bf6cd1132ad515c93

调试

 Services/MesOrderStaManager.cs

@@ -91,14 +91,13 @@
    }

    /// <summary>
    ///     更新机器时间并处理首检
    ///     逻辑说明：
    ///     1) 首检结果“不合格”不立即重建，等待用户再次点击送检呼叫（送检时间变化）触发重建
    ///     2) 首次无首检单或“不合格”且送检时间变化 => 调用存储过程重建首检单
    ///     3) 重建后保留当前送检时间，不清空
    ///     4) 不合格但送检时间未变化 => 提示用户需要重新送检
    ///     5) 合格且送检时间 >= 调机开始时间 => 写入开工与调机完成时间
    ///     可选扩展：支持 ForceRebuild 强制重建（如果前端加字段）
    /// 调机送检逻辑重写版
    /// 流程：
    /// 1. 调机开始：只写入调机开始时间(MA_START_TIME)
    /// 2. 送检呼叫：写入调机开始时间(若未写)与送检时间(MA_SHOUT_TIME)，并创建首检单
    /// 3. 调机完成：保持原逻辑，首检合格后写入开工(START_TIME)与调机完成(MA_END_TIME)
    /// 4. 若最新首检结果为“不合格”，清空送检时间(MA_SHOUT_TIME)，提示重新送检，不立即重建
    ///    用户再次点击送检呼叫才创建新的首检单
    /// </summary>
    public bool ChangeMachineTime(MesOrderSta entity)
    {
@@ -106,53 +105,76 @@
        const string FirstCheckResultOK = "合格";
        const string FirstCheckResultNG = "不合格";

        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("工单不存在");

        // 当前数据库状态快照
        var dbSta = Db.Queryable<MesOrderSta>().Where(s => s.Id == entity.Id).First();
        if (dbSta == null) throw new Exception("工单状态不存在");

        // 行级锁
        // 行级锁，保证创建首检单的并发安全
        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"))
            .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();

        // ForceRebuild 可选扩展
        var forceRebuild = (entity as dynamic)?.ForceRebuild == true;
        // 判定操作类型
        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;
        // 完成逻辑保持：后面通过首检合格条件判断

        // 立即重建条件：首次无单 或 最新结果 == 不合格 或 强制
        var needRebuild = latestFirst == null
                          || string.Equals(latestResult, FirstCheckResultNG, StringComparison.OrdinalIgnoreCase)
                          || forceRebuild;

        if (needRebuild)
        // 4) 若最新判定结果“不合格”，清空送检时间，提示需重新呼叫，不创建新单
        if (string.Equals(latestResult, FirstCheckResultNG, StringComparison.OrdinalIgnoreCase))
        {
            var previousState = latestResult == null ? "首次创建"
                : (latestResult == FirstCheckResultNG ? "不合格后立即重建" : "重建");
            // 清空送检时间（数据库与返回实体）
            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;
        }

            // 可选：保留旧记录，或标记旧记录作废（如果需要避免多条待检）
            // 若要作废上一条不合格单：取消即可
            if (latestFirst != null && string.Equals(latestResult, FirstCheckResultNG, StringComparison.OrdinalIgnoreCase))
            {
                Db.Updateable<MesQaItemsDetect02>()
                  .SetColumns(s => s.Fcancel == "Y")
                  .Where(s => s.Id == latestFirst.Id)
                  .ExecuteCommand();
            }
        // 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();

@@ -160,101 +182,51 @@
            {
                var ts = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                Db.Updateable<MesQaItemsDetect02>()
                  .SetColumns(s => s.Remeke == $"工控机于{ts}自动创建的首检单({previousState})")
                  .Where(s => s.Id == latestFirst.Id)
                  .ExecuteCommand();
                    .SetColumns(s => s.Remeke == $"工控机于{ts}调机送检生成首检单")
                    .Where(s => s.Id == latestFirst.Id)
                    .ExecuteCommand();
            }

            if (previousState.Contains("不合格"))
                entity.remark = "不合格已重建，等待检验";
        }
        else
        {
            // 不需要重建时仅写结果备注（若已有首检）
            if (latestFirst != null && !string.IsNullOrEmpty(latestResult))
            {
                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();
            }
            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
        {
            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)
            {
                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}");
        }

        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();

        // 合格写开工/调机完成
        // 3) 保留调机完成逻辑：首检合格且送检时间 >= 调机开始时间时自动写开工与调机完成
        // （此处与原逻辑一致：前端不直接点“调机完成”，而是由合格触发）
        if (!string.IsNullOrEmpty(entity.MaShoutTime)
            && DateTime.TryParse(entity.MaShoutTime, out var sjTime)
            && DateTime.TryParse(entity.MaStartTime, out var startTime)
            && sjTime >= startTime
            && 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))
        {
            // 写开工及调机完成
            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");

            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;
        }

        return Db.Updateable<MesOrderSta>()
            .SetColumnsIF(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)
            .ExecuteCommand() > 0;
        // 若本次调用未匹配任何操作（可能只是重复提交），保持不变
        return true;
    }