SJ穴模数

xwt

2025-09-17 d610083a5554baaf3af34f73b528c5022959ee77

 StandardInterface/MES.Service/service/QC/SJService.cs

@@ -3,6 +3,7 @@
using MES.Service.Modes;
using MES.Service.util;
using SqlSugar;
using System.Data;

namespace MES.Service.service.QC;

@@ -30,7 +31,7 @@
            number = no.ToString().PadLeft(4, '0');
        }

        return "SJN" + date.Replace("-", "") + number;
        return "SJ" + date.Replace("-", "") + number;
    }

    //获取所有数据分页
@@ -52,11 +53,11 @@
            .WhereIF(
                StringUtil.IsNotNullOrEmpty(queryObj.Result) &&
                "未完成".Equals(queryObj.Result),
                a => a.Result == queryObj.Result)
                a => a.Fsubmit == 0)
            .WhereIF(
                StringUtil.IsNotNullOrEmpty(queryObj.Result) &&
                !"未完成".Equals(queryObj.Result),
                a => a.Result != "未完成");
                a => a.Fsubmit == 1);

        // 新增的动态搜索逻辑
        if (!string.IsNullOrEmpty(queryObj.SearchValue) && !string.IsNullOrEmpty(queryObj.searchField))
@@ -177,14 +178,42 @@
    public List<QsItemIpiItem> getQSItems(decimal? pid, decimal? id)
    {
        var db = SqlSugarHelper.GetInstance();
        
        // 使用JOIN查询获取子表数据和主表的MNUM、DNUM字段
        var qsItemIpiItems = db
            .Queryable<QsItemIpiItem>()
            .WhereIF(pid > 0, a => a.Pid == pid)
            .WhereIF(id > 0, a => a.Id == id).ToList();
            .Queryable<QsItemIpiItem, QsItemIpiReq>((a, b) => new JoinQueryInfos(JoinType.Left, a.Pid == b.Id))
            .WhereIF(pid > 0, (a, b) => a.Pid == pid)
            .WhereIF(id > 0, (a, b) => a.Id == id)
            .Select((a, b) => new QsItemIpiItem
            {
                Id = a.Id,
                Pid = a.Pid,
                ProjName = a.ProjName,
                ItemMod = a.ItemMod,
                InspectionMethod = a.InspectionMethod,
                UsingInstruments = a.UsingInstruments,
                LevelNum = a.LevelNum,
                MaxValue = a.MaxValue,
                StandardValue = a.StandardValue,
                MinValue = a.MinValue,
                Notes = a.Notes,
                FcheckLevel = a.FcheckLevel,
                FacLevel = a.FacLevel,
                QsCode = a.QsCode,
                QsName = a.QsName,
                Picture = a.Picture,
                Picturename = a.Picturename,
                IsPass = a.IsPass,
                ItemId = a.ItemId,
                Mnum = b.Mnum,  // 从主表获取MNUM
                Dnum = b.Dnum,  // 从主表获取DNUM
                Snum = a.Snum,  // 送检批数
                Remarks = a.Remarks
            }).ToList();

        var array = qsItemIpiItems.Select(s => s.Id).ToArray();
        var qsItemIpiItemDetails = db.Queryable<QsItemIpiItemDetail>()
            .Where(s => array.Contains(s.Pid))
            .Where(s => array.Contains(s.Pid) && s.FcheckResu != "/")
            .GroupBy(s => s.Pid)
            .Select(s => new
            {
@@ -203,12 +232,59 @@
            else
            {
                s.isCheck = find.count;
                if (find.count == s.LevelNum && s.IsPass == 1)
                    s.result = "合格";
                else if (find.count == s.LevelNum && s.IsPass == 0)
                    s.result = "不合格";
                
                // 计算实际需要检验的数量（排除堵穴）
                int actualRequiredCount = (int)(s.LevelNum ?? 0);
                if (s.HoleNumbers != null && s.HoleNumbers.Count > 0)
                {
                    // 如果有穴号信息，计算非堵穴的数量
                    actualRequiredCount = s.HoleNumbers.Count(h => !h.IsBlocked);
                }
                
                // 调试信息：结果判定
                Console.WriteLine($"getQSItems: Pid={s.Id}, find.count={find.count}, actualRequiredCount={actualRequiredCount}, IsPass={s.IsPass}");
                
                // 如果有检验记录，根据合格情况判断状态
                if (find.count > 0)
                {
                    // 获取合格数量
                    var passCount = db.Queryable<QsItemIpiItemDetail>()
                        .Where(a => a.Pid == s.Id && a.Fstand == "√" && a.FcheckResu != "/").Count();
                    
                    // 获取不合格数量
                    var failCount = db.Queryable<QsItemIpiItemDetail>()
                        .Where(a => a.Pid == s.Id && a.Fstand == "×" && a.FcheckResu != "/").Count();
                    
                    // 如果有不合格记录，直接显示不合格
                    if (failCount > 0)
                    {
                        s.result = "不合格";
                    }
                    // 如果全部合格且数量匹配，显示合格
                    else if (passCount == actualRequiredCount && find.count == actualRequiredCount)
                    {
                        s.result = "合格";
                    }
                    // 如果部分完成，显示进行中
                    else if (find.count < actualRequiredCount)
                    {
                        s.result = "进行中";
                    }
                    // 如果全部完成但合格数量不足，显示不合格
                    else if (find.count == actualRequiredCount && passCount < actualRequiredCount)
                    {
                        s.result = "不合格";
                    }
                    // 其他情况显示进行中
                    else
                    {
                        s.result = "进行中";
                    }
                }
                else
                {
                    s.result = "未完成";
                }
            }
        });

@@ -226,6 +302,16 @@

        //排序，未完成的排在前面
        qsItemIpiItems = qsItemIpiItems.OrderBy(s => s.isCheck).ToList();

        // 为每个检验项目生成穴号信息
        qsItemIpiItems.ForEach(item =>
        {
            if (item.Mnum > 0 && item.Snum > 0)
            {
                // 使用SNUM作为送检批数来计算总编号数量
                item.HoleNumbers = GenerateHoleNumbers(item.Mnum, item.Dnum, item.Snum);
            }
        });

        return qsItemIpiItems;
    }
@@ -262,7 +348,24 @@
            detail.Fstand = "√";
            detail.FcheckResu = "1";
            detail.UpdateBy = item.From.StatusUser;
            detail.count = (int?)s.LevelNum;
            
            // 计算默认合格的数量：(检验数 * 开穴数) - (检验数 * 堵穴数)
            if (s.HoleNumbers != null && s.HoleNumbers.Count > 0)
            {
                // 如果有穴号信息，计算开穴数和堵穴数
                int openHoles = s.HoleNumbers.Count(h => !h.IsBlocked);  // 开穴数
                int blockedHoles = s.HoleNumbers.Count(h => h.IsBlocked);  // 堵穴数
                int checkCount = (int)(s.LevelNum ?? 1);  // 检验数
                
                // 计算：(检验数 * 开穴数) - (检验数 * 堵穴数)
                detail.count = (checkCount * openHoles) - (checkCount * blockedHoles);
            }
            else
            {
                // 否则使用LevelNum
                detail.count = (int?)s.LevelNum;
            }
            
            SetQSItemDetail(detail);
        });

@@ -298,7 +401,24 @@
            detail.Fstand = "√";
            detail.FcheckResu = "1";
            detail.UpdateBy = item.StatusUser;
            detail.count = (int?)s.LevelNum;
            
            // 计算默认合格的数量：(检验数 * 开穴数) - (检验数 * 堵穴数)
            if (s.HoleNumbers != null && s.HoleNumbers.Count > 0)
            {
                // 如果有穴号信息，计算开穴数和堵穴数
                int openHoles = s.HoleNumbers.Count(h => !h.IsBlocked);  // 开穴数
                int blockedHoles = s.HoleNumbers.Count(h => h.IsBlocked);  // 堵穴数
                int checkCount = (int)(s.LevelNum ?? 1);  // 检验数
                
                // 计算：(检验数 * 开穴数) - (检验数 * 堵穴数)
                detail.count = (checkCount * openHoles) - (checkCount * blockedHoles);
            }
            else
            {
                // 否则使用LevelNum
                detail.count = (int?)s.LevelNum;
            }
            
            SetQSItemDetail(detail);
        });

@@ -312,6 +432,10 @@
        var oracle = SqlSugarHelper.UseTransactionWithOracle(db =>
        {
            List<QsItemIpiItemDetail> result = new();
            
            // 获取起始索引，如果没有指定则从0开始
            int startIndex = detail.startIndex ?? 0;
            
            for (var i = 0; i < detail.count; i++)
            {
                var item = new QsItemIpiItemDetail();
@@ -321,6 +445,9 @@
                item.FcheckResu = detail.FcheckResu;
                item.CreateBy = detail.UpdateBy;
                item.CreateDate = DateTime.Now;
                
                // 如果有起始索引，可以在这里设置相关的索引信息
                // 注意：这里只是示例，实际可能需要根据业务需求调整
                result.Add(item);
            }

@@ -356,17 +483,38 @@
        if (qsItemIpiItem == null) return 0;

        var count = db.Queryable<QsItemIpiItemDetail>()
            .Where(s => s.Pid == detail.Pid).Count();
            .Where(s => s.Pid == detail.Pid && s.FcheckResu != "/").Count();

        // 计算实际需要检验的数量（排除堵穴）
        var actualRequiredCount = qsItemIpiItem.LevelNum;
        if (qsItemIpiItem.HoleNumbers != null && qsItemIpiItem.HoleNumbers.Count > 0)
        {
            // 如果有穴号信息，计算非堵穴的数量
            actualRequiredCount = qsItemIpiItem.HoleNumbers.Count(h => !h.IsBlocked);
        }

        var result = 0;

        if (qsItemIpiItem.LevelNum != count) return 0;
        // 比较实际需要检验的数量和实际检验记录数量
        if (actualRequiredCount != count) 
        {
            // 调试信息：记录数量不匹配
            Console.WriteLine($"autoResult: actualRequiredCount={actualRequiredCount}, count={count}, Pid={detail.Pid}");
            // 即使数量不匹配，也要继续执行后续逻辑来更新IS_PASS字段
            // return 0; // 注释掉这行，让方法继续执行
        }

        var passCount = db.Queryable<QsItemIpiItemDetail>()
            .Where(s => s.Pid == detail.Pid && s.Fstand == "√").Count();
            .Where(s => s.Pid == detail.Pid && s.Fstand == "√" && s.FcheckResu != "/").Count();

        if (count == passCount) result = 1;
        // 调试信息：统计信息
        Console.WriteLine($"autoResult: count={count}, passCount={passCount}, Pid={detail.Pid}");

        // 只有在数量匹配时才进行合格性判断
        if (actualRequiredCount == count && count == passCount) 
        {
            result = 1;
        }

        var useTransactionWithOracle = SqlSugarHelper.UseTransactionWithOracle(
            db =>
@@ -381,14 +529,30 @@


        //自动判定是否合格
        //获取检验单的检验项目理论个数
        var sum = db.Queryable<QsItemIpiItem>()
            .Where(s => s.Pid == detail.Gid).Sum(it => it.LevelNum);
        if (sum == null || sum == 0) return 1;
        //获取检验单的检验项目实际需要检验个数（排除堵穴）
        var sum = 0;
        var qsItems = db.Queryable<QsItemIpiItem>()
            .Where(s => s.Pid == detail.Gid).ToList();
        
        foreach (var item in qsItems)
        {
            if (item.HoleNumbers != null && item.HoleNumbers.Count > 0)
            {
                // 如果有穴号信息，计算非堵穴的数量
                sum += item.HoleNumbers.Count(h => !h.IsBlocked);
            }
            else
            {
                // 否则使用LevelNum
                sum += (int)(item.LevelNum ?? 0);
            }
        }
        
        if (sum == 0) return 1;

        //获取检验单下的检验项目实际个数
        //获取检验单下的检验项目实际个数（排除堵穴）
        var icount = db.Queryable<QsItemIpiItemDetail>()
            .Where(s => s.Gid == detail.Gid).Count();
            .Where(s => s.Gid == detail.Gid && s.FcheckResu != "/").Count();

        if (icount == 0) return 1;

@@ -501,4 +665,139 @@

        return withOracle;
    }
    //刷新检验项目
    public (int result, string message) GenUpdate(decimal? id, string? no, string? user, decimal? mnum = null, string? dnum = null)
    {
        var outputResult = new SugarParameter("PO_RESULT", null, System.Data.DbType.Int32, ParameterDirection.Output, 4000);
        var outputMessage = new SugarParameter("PO_TEXT", null, System.Data.DbType.String, ParameterDirection.Output, 4000);

        var parameters = new List<SugarParameter>
    {
        new("P_ID", id, System.Data.DbType.Decimal, ParameterDirection.Input),
        new("P_NO", no, System.Data.DbType.String, ParameterDirection.Input),
        new("P_USER", user, System.Data.DbType.String, ParameterDirection.Input),
        new("P_MNUM", mnum ?? 1, System.Data.DbType.Decimal, ParameterDirection.Input),
        new("P_DNUM", dnum ?? "", System.Data.DbType.String, ParameterDirection.Input),
        outputResult,
        outputMessage
    };

        var db = SqlSugarHelper.GetInstance();
        db.Ado.ExecuteCommand(
            "BEGIN PRC_GEN_UPDATE(:P_ID,:P_NO,:P_MNUM,:P_DNUM,:P_USER, :PO_RESULT, :PO_TEXT); END;",
            parameters.ToArray());

        int result = outputResult.Value == null ? -1 : Convert.ToInt32(outputResult.Value);
        string message = outputMessage.Value?.ToString() ?? "";

        return (result, message);
    }

    public bool SjSubmit(SJDto dto)
    {
        try
        {
            // 定义输出参数
            var outputResult = new SugarParameter("c_res", null,
                System.Data.DbType.Int32, ParameterDirection.Output,
                4000);

            var outputMessage = new SugarParameter("c_msg", null,
                System.Data.DbType.String,
                ParameterDirection.Output, 4000);

            // 定义输入参数，固定FLAG为1（审核）
            var parameters = new List<SugarParameter>
            {
                new("P_ID", dto.id, System.Data.DbType.Decimal, ParameterDirection.Input),
                new("P_FLAG", 1, System.Data.DbType.Int32, ParameterDirection.Input),
                new("P_USER", dto.userNo, System.Data.DbType.String, ParameterDirection.Input),
                outputResult,
                outputMessage
            };

            var db = SqlSugarHelper.GetInstance();

            // 使用 SqlSugar 执行存储过程
            db.Ado.ExecuteCommand(
                "BEGIN PRC_WOMDAA_SJ_UPDATE_RES(:P_ID, :P_FLAG, :P_USER, :c_res, :c_msg); END;",
                parameters.ToArray());

            // 获取输出参数的值
            var resultValue = outputResult.Value?.ToString();
            var messageValue = outputMessage.Value?.ToString();

            if ("1".Equals(resultValue)) throw new Exception(messageValue);

            return true;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
    }

    /// <summary>
    /// 生成穴号信息
    /// </summary>
    /// <param name="mnum">开穴总数</param>
    /// <param name="dnum">堵穴号（逗号分隔）</param>
    /// <param name="snum">送检批数</param>
    /// <returns>穴号信息列表</returns>
    private List<HoleNumberInfo> GenerateHoleNumbers(decimal? mnum, string? dnum, decimal? snum)
    {
        var result = new List<HoleNumberInfo>();
        
        if (mnum == null || mnum <= 0 || snum == null || snum <= 0)
            return result;

        // 解析堵穴号
        var blockedHoles = new HashSet<int>();
        if (!string.IsNullOrEmpty(dnum))
        {
            var holeNumbers = dnum.Split(',', StringSplitOptions.RemoveEmptyEntries);
            foreach (var holeStr in holeNumbers)
            {
                if (int.TryParse(holeStr.Trim(), out int holeNum))
                {
                    blockedHoles.Add(holeNum);
                }
            }
        }

        int totalHoles = (int)mnum.Value;
        int batchCount = (int)snum.Value; // 送检批数
        
        // 计算总编号数量：开穴总数 × 送检批数
        int totalIndexes = totalHoles * batchCount;
        
        for (int i = 1; i <= totalIndexes; i++)
        {
            // 穴号循环：1-8, 1-8...
            int holeNumber = ((i - 1) % totalHoles) + 1;
            bool isBlocked = blockedHoles.Contains(holeNumber);
            
            result.Add(new HoleNumberInfo
            {
                Index = i,
                HoleNumber = holeNumber,
                IsBlocked = isBlocked,
                RecordValue = isBlocked ? "/" : null,
                CheckResult = isBlocked ? "/" : null
            });
        }

        // 排序：堵穴排最后优先级第一，然后穴号从小到大排，穴号相同的排一起
        result = result.OrderBy(x => x.IsBlocked)            // 堵穴排最后（false在前，true在后）
                      .ThenBy(x => x.HoleNumber)             // 穴号从小到大
                      .ToList();

        // 重新设置Index，保持连续编号
        for (int i = 0; i < result.Count; i++)
        {
            result[i].Index = i + 1;
        }

        return result;
    }
}