AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Controllers/S0/Quality/AdoS0QualityFqcOqcControllers.cs

using Admin.NET.Plugin.AiDOP.Dto.S0.Quality;
using Admin.NET.Plugin.AiDOP.Entity.S0.Quality;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using static Admin.NET.Plugin.AiDOP.Controllers.S0.Quality.AdoS0QmsControllerHelpers;

namespace Admin.NET.Plugin.AiDOP.Controllers.S0.Quality;

[ApiController]
[Route("api/s0/quality/fqc-inspection-specs")]
[NonUnify]
public class AdoS0QmsFqcInspectionSpecsController : ControllerBase
{
    private readonly SqlSugarRepository<AdoS0QmsFqcInspectionSpec> _rep;
    private readonly SqlSugarRepository<AdoS0QmsFqcInspectionSpecEntry> _entryRep;

    public AdoS0QmsFqcInspectionSpecsController(
        SqlSugarRepository<AdoS0QmsFqcInspectionSpec> rep,
        SqlSugarRepository<AdoS0QmsFqcInspectionSpecEntry> entryRep)
    {
        _rep = rep;
        _entryRep = entryRep;
    }

    [HttpGet]
    public async Task<IActionResult> GetPagedAsync([FromQuery] AdoS0QualityPagedQueryDto q)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        (q.Page, q.PageSize) = PagingGuard.Normalize(q.Page, q.PageSize);
        var query = _rep.AsQueryable().Where(x => x.TenantId == tenantId)
            .WhereIF(!string.IsNullOrWhiteSpace(q.Keyword), x =>
                (x.FileNumber != null && x.FileNumber.Contains(q.Keyword!))
                || (x.ApplicableModel != null && x.ApplicableModel.Contains(q.Keyword!))
                || (x.MaterialCode != null && x.MaterialCode.Contains(q.Keyword!)));
        var total = await query.CountAsync();
        var list = await query.OrderByDescending(x => x.Id).Skip((q.Page - 1) * q.PageSize).Take(q.PageSize).ToListAsync();
        return Ok(new { total, page = q.Page, pageSize = q.PageSize, list });
    }

    [HttpGet("{id:long}")]
    public async Task<IActionResult> GetDetailAsync(long id)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var master = await _rep.ByIdScopedByColumnAsync(id, tenantId);
        if (master == null) return NotFound();
        var items = await _entryRep.AsQueryable().Where(x => x.MasterId == id).OrderBy(x => x.Id).ToListAsync();
        return Ok(new { master, items });
    }

    [HttpPost]
    public async Task<IActionResult> CreateAsync([FromBody] AdoS0QmsFqcInspectionSpecUpsertDto dto)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var items = AdoS0QmsSpecAggregateGuard.Meaningful(dto.Items);
        var guardError = AdoS0QmsSpecAggregateGuard.ValidateCreate(FqcRequiredFields(dto), items.Count);
        if (guardError != null) return AdoS0ApiErrors.InvalidRequest(guardError);
        var db = _rep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            var master = new AdoS0QmsFqcInspectionSpec();
            ApplyFqcSpec(master, dto);
            master.TenantId = tenantId;
            await _rep.AsInsertable(master).ExecuteReturnEntityAsync();
            await SyncFqcEntriesAsync(master.Id, items, tenantId);
            await db.Ado.CommitTranAsync();
            return await GetDetailAsync(master.Id);
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    [HttpPut("{id:long}")]
    public async Task<IActionResult> UpdateAsync(long id, [FromBody] AdoS0QmsFqcInspectionSpecUpsertDto dto)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var master = await _rep.ByIdScopedByColumnAsync(id, tenantId);
        if (master == null) return NotFound();
        // 写入集保留历史已持久化的明细行（含空行），只丢弃本次新补的空占位；
        // 「原有明细数」按 meaningful 计，避免全空明细的历史单被自己的空行锁死。
        var existingRows = await _entryRep.AsQueryable().Where(x => x.MasterId == id).ToListAsync();
        var items = AdoS0QmsSpecAggregateGuard.ForUpdateWrite(dto.Items);
        var guardError = AdoS0QmsSpecAggregateGuard.ValidateUpdate(
            [
                ("文件编号", master.FileNumber, dto.FileNumber),
                ("物料编码", master.MaterialCode, dto.MaterialCode),
                ("版本", master.VersionNo, dto.VersionNo)
            ],
            AdoS0QmsSpecAggregateGuard.CountMeaningful(existingRows),
            AdoS0QmsSpecAggregateGuard.Meaningful(dto.Items).Count);
        if (guardError != null) return AdoS0ApiErrors.InvalidRequest(guardError);
        var db = _rep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            ApplyFqcSpec(master, dto);
            await _rep.AsUpdateable(master).ExecuteCommandAsync();
            await _entryRep.AsDeleteable().Where(x => x.MasterId == id).ExecuteCommandAsync();
            await SyncFqcEntriesAsync(id, items, tenantId);
            await db.Ado.CommitTranAsync();
            return await GetDetailAsync(id);
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    [HttpDelete("{id:long}")]
    public async Task<IActionResult> DeleteAsync(long id)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var master = await _rep.ByIdScopedByColumnAsync(id, tenantId);
        if (master == null) return NotFound();
        var db = _rep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            await _entryRep.AsDeleteable().Where(x => x.MasterId == id).ExecuteCommandAsync();
            await _rep.DeleteAsync(master);
            await db.Ado.CommitTranAsync();
            return Ok(new { message = "删除成功" });
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    /// <summary>FQC 检规必填集（UAT-S0-10 拍板；本轮不含「适用型号」，缺业务依据）。</summary>
    private static IReadOnlyList<(string, string?)> FqcRequiredFields(AdoS0QmsFqcInspectionSpecUpsertDto dto) =>
    [
        ("文件编号", dto.FileNumber),
        ("物料编码", dto.MaterialCode),
        ("版本", dto.VersionNo),
    ];


    private static void ApplyFqcSpec(AdoS0QmsFqcInspectionSpec entity, AdoS0QmsFqcInspectionSpecUpsertDto dto)
    {
        entity.ApplicableModel = NullIfWhiteSpace(dto.ApplicableModel);
        entity.FileNumber = NullIfWhiteSpace(dto.FileNumber);
        entity.VersionNo = NullIfWhiteSpace(dto.VersionNo);
        entity.EffectiveDate = NullIfWhiteSpace(dto.EffectiveDate);
        entity.Attachment = NullIfWhiteSpace(dto.Attachment);
        entity.MaterialCode = NullIfWhiteSpace(dto.MaterialCode);
        entity.Attachment2 = NullIfWhiteSpace(dto.Attachment2);
        entity.Version = dto.Version;
    }

    private async Task SyncFqcEntriesAsync(long masterId, IEnumerable<AdoS0QmsFqcInspectionSpecEntryDto> items, long tenantId)
    {
        foreach (var item in items)
        {
            var entity = new AdoS0QmsFqcInspectionSpecEntry
            {
                TenantId = tenantId,
                MasterId = masterId,
                OperationCode = NullIfWhiteSpace(item.OperationCode),
                OperationName = NullIfWhiteSpace(item.OperationName),
                InspectionItem = NullIfWhiteSpace(item.InspectionItem),
                InspectionMethod = NullIfWhiteSpace(item.InspectionMethod),
                InspectionSpec = NullIfWhiteSpace(item.InspectionSpec),
                ImageCategory = NullIfWhiteSpace(item.ImageCategory),
                InspectionFrequency = NullIfWhiteSpace(item.InspectionFrequency),
                TechnicalStandard = NullIfWhiteSpace(item.TechnicalStandard),
                PeelingForce = item.PeelingForce,
                UpperLimit = NullIfWhiteSpace(item.UpperLimit),
                LowerLimit = NullIfWhiteSpace(item.LowerLimit)
            };
            await _entryRep.AsInsertable(entity).ExecuteCommandAsync();
        }
    }
}

[ApiController]
[Route("api/s0/quality/oqc-inspection-specs")]
[NonUnify]
public class AdoS0QmsOqcInspectionSpecsController : ControllerBase
{
    private readonly SqlSugarRepository<AdoS0QmsOqcInspectionSpec> _rep;
    private readonly SqlSugarRepository<AdoS0QmsOqcInspectionSpecEntry> _entryRep;

    public AdoS0QmsOqcInspectionSpecsController(
        SqlSugarRepository<AdoS0QmsOqcInspectionSpec> rep,
        SqlSugarRepository<AdoS0QmsOqcInspectionSpecEntry> entryRep)
    {
        _rep = rep;
        _entryRep = entryRep;
    }

    [HttpGet]
    public async Task<IActionResult> GetPagedAsync([FromQuery] AdoS0QualityPagedQueryDto q)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        (q.Page, q.PageSize) = PagingGuard.Normalize(q.Page, q.PageSize);
        var query = _rep.AsQueryable().Where(x => x.TenantId == tenantId)
            .WhereIF(!string.IsNullOrWhiteSpace(q.Keyword), x =>
                (x.FileNumber != null && x.FileNumber.Contains(q.Keyword!))
                || (x.ApplicableModel != null && x.ApplicableModel.Contains(q.Keyword!))
                || (x.MaterialCode != null && x.MaterialCode.Contains(q.Keyword!)));
        var total = await query.CountAsync();
        var list = await query.OrderByDescending(x => x.Id).Skip((q.Page - 1) * q.PageSize).Take(q.PageSize).ToListAsync();
        return Ok(new { total, page = q.Page, pageSize = q.PageSize, list });
    }

    [HttpGet("{id:long}")]
    public async Task<IActionResult> GetDetailAsync(long id)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var master = await _rep.ByIdScopedByColumnAsync(id, tenantId);
        if (master == null) return NotFound();
        var items = await _entryRep.AsQueryable().Where(x => x.MasterId == id).OrderBy(x => x.Id).ToListAsync();
        return Ok(new { master, items });
    }

    [HttpPost]
    public async Task<IActionResult> CreateAsync([FromBody] AdoS0QmsOqcInspectionSpecUpsertDto dto)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var items = AdoS0QmsSpecAggregateGuard.Meaningful(dto.Items);
        var guardError = AdoS0QmsSpecAggregateGuard.ValidateCreate(OqcRequiredFields(dto), items.Count);
        if (guardError != null) return AdoS0ApiErrors.InvalidRequest(guardError);
        var db = _rep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            var master = new AdoS0QmsOqcInspectionSpec();
            ApplyOqcSpec(master, dto);
            master.TenantId = tenantId;
            await _rep.AsInsertable(master).ExecuteReturnEntityAsync();
            await SyncOqcEntriesAsync(master.Id, items, tenantId);
            await db.Ado.CommitTranAsync();
            return await GetDetailAsync(master.Id);
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    [HttpPut("{id:long}")]
    public async Task<IActionResult> UpdateAsync(long id, [FromBody] AdoS0QmsOqcInspectionSpecUpsertDto dto)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var master = await _rep.ByIdScopedByColumnAsync(id, tenantId);
        if (master == null) return NotFound();
        // 写入集保留历史已持久化的明细行（含空行），只丢弃本次新补的空占位；
        // 「原有明细数」按 meaningful 计，避免全空明细的历史单被自己的空行锁死。
        var existingRows = await _entryRep.AsQueryable().Where(x => x.MasterId == id).ToListAsync();
        var items = AdoS0QmsSpecAggregateGuard.ForUpdateWrite(dto.Items);
        var guardError = AdoS0QmsSpecAggregateGuard.ValidateUpdate(
            [
                ("文件编号", master.FileNumber, dto.FileNumber),
                ("物料编码", master.MaterialCode, dto.MaterialCode),
                ("版本", master.VersionNo, dto.VersionNo)
            ],
            AdoS0QmsSpecAggregateGuard.CountMeaningful(existingRows),
            AdoS0QmsSpecAggregateGuard.Meaningful(dto.Items).Count);
        if (guardError != null) return AdoS0ApiErrors.InvalidRequest(guardError);
        var db = _rep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            ApplyOqcSpec(master, dto);
            await _rep.AsUpdateable(master).ExecuteCommandAsync();
            await _entryRep.AsDeleteable().Where(x => x.MasterId == id).ExecuteCommandAsync();
            await SyncOqcEntriesAsync(id, items, tenantId);
            await db.Ado.CommitTranAsync();
            return await GetDetailAsync(id);
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    [HttpDelete("{id:long}")]
    public async Task<IActionResult> DeleteAsync(long id)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var master = await _rep.ByIdScopedByColumnAsync(id, tenantId);
        if (master == null) return NotFound();
        var db = _rep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            await _entryRep.AsDeleteable().Where(x => x.MasterId == id).ExecuteCommandAsync();
            await _rep.DeleteAsync(master);
            await db.Ado.CommitTranAsync();
            return Ok(new { message = "删除成功" });
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    /// <summary>OQC 检规必填集（UAT-S0-10 拍板；本轮不含「适用型号」，缺业务依据）。</summary>
    private static IReadOnlyList<(string, string?)> OqcRequiredFields(AdoS0QmsOqcInspectionSpecUpsertDto dto) =>
    [
        ("文件编号", dto.FileNumber),
        ("物料编码", dto.MaterialCode),
        ("版本", dto.VersionNo),
    ];


    private static void ApplyOqcSpec(AdoS0QmsOqcInspectionSpec entity, AdoS0QmsOqcInspectionSpecUpsertDto dto)
    {
        entity.ApplicableModel = NullIfWhiteSpace(dto.ApplicableModel);
        entity.FileNumber = NullIfWhiteSpace(dto.FileNumber);
        entity.VersionNo = NullIfWhiteSpace(dto.VersionNo);
        entity.EffectiveDate = NullIfWhiteSpace(dto.EffectiveDate);
        entity.Attachment = NullIfWhiteSpace(dto.Attachment);
        entity.MaterialCode = NullIfWhiteSpace(dto.MaterialCode);
        entity.Attachment2 = NullIfWhiteSpace(dto.Attachment2);
        entity.Version = dto.Version;
    }

    private async Task SyncOqcEntriesAsync(long masterId, IEnumerable<AdoS0QmsOqcInspectionSpecEntryDto> items, long tenantId)
    {
        foreach (var item in items)
        {
            var entity = new AdoS0QmsOqcInspectionSpecEntry
            {
                TenantId = tenantId,
                MasterId = masterId,
                OperationCode = NullIfWhiteSpace(item.OperationCode),
                OperationName = NullIfWhiteSpace(item.OperationName),
                InspectionItem = NullIfWhiteSpace(item.InspectionItem),
                InspectionMethod = NullIfWhiteSpace(item.InspectionMethod),
                InspectionSpec = NullIfWhiteSpace(item.InspectionSpec),
                ImageCategory = NullIfWhiteSpace(item.ImageCategory),
                InspectionFrequency = NullIfWhiteSpace(item.InspectionFrequency),
                TechnicalStandard = NullIfWhiteSpace(item.TechnicalStandard),
                PeelingForce = item.PeelingForce,
                UpperLimit = NullIfWhiteSpace(item.UpperLimit),
                LowerLimit = NullIfWhiteSpace(item.LowerLimit)
            };
            await _entryRep.AsInsertable(entity).ExecuteCommandAsync();
        }
    }
}