AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Controllers/S0/Manufacturing/AdoS0MfgRoutingOpDetailsController.cs

using Admin.NET.Plugin.AiDOP.Dto.S0.Manufacturing;
using Admin.NET.Plugin.AiDOP.Dto.S0.Sales;
using Admin.NET.Plugin.AiDOP.Entity.S0.Manufacturing;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using Microsoft.Extensions.Logging;

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

[ApiController]
[Route("api/s0/manufacturing/routing-op-details")]
[NonUnify]
public class AdoS0MfgRoutingOpDetailsController : ControllerBase
{
    private readonly SqlSugarRepository<AdoS0MfgRoutingOpDetail> _rep;
    private readonly AdoS0ReferenceChecker _refChecker;
    private readonly ILogger<AdoS0MfgRoutingOpDetailsController> _logger;

    public AdoS0MfgRoutingOpDetailsController(
        SqlSugarRepository<AdoS0MfgRoutingOpDetail> rep,
        AdoS0ReferenceChecker refChecker,
        ILogger<AdoS0MfgRoutingOpDetailsController> logger)
    {
        _rep = rep;
        _refChecker = refChecker;
        _logger = logger;
    }

    [HttpGet]
    public async Task<IActionResult> GetPagedAsync([FromQuery] AdoS0MfgRoutingOpDetailQueryDto q)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var page = q.EffectivePage;
        var pageSize = q.PageSize;
        (page, pageSize) = PagingGuard.Normalize(page, pageSize);

        var query = _rep.ScopedTo(tenantId)
            .WhereIF(q.CompanyRefId.HasValue, x => x.CompanyRefId == q.CompanyRefId!.Value)
            .WhereIF(q.FactoryRefId.HasValue, x => x.FactoryRefId == q.FactoryRefId!.Value)
            .WhereIF(!string.IsNullOrWhiteSpace(q.Keyword), x =>
                x.RouteCode.Contains(q.Keyword!) ||
                x.RouteName.Contains(q.Keyword!) ||
                x.MaterialCode.Contains(q.Keyword!) ||
                x.OperationCode.Contains(q.Keyword!) ||
                x.OperationDescription.Contains(q.Keyword!) ||
                x.WorkCenterCode.Contains(q.Keyword!))
            .WhereIF(q.IsEnabled.HasValue, x => x.IsEnabled == q.IsEnabled!.Value);

        var total = await query.CountAsync();
        var list = await query.OrderBy(x => x.RouteCode).OrderBy(x => x.SortNo).OrderBy(x => x.Id)
            .Skip((page - 1) * pageSize).Take(pageSize).ToListAsync();
        return Ok(new { total, page, pageSize, list });
    }

    [HttpGet("{id:long}")]
    public async Task<IActionResult> GetAsync(long id)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var item = await _rep.ByIdScopedAsync(id, tenantId);
        return item == null ? NotFound() : Ok(item);
    }

    [HttpPost]
    public async Task<IActionResult> CreateAsync([FromBody] AdoS0MfgRoutingOpDetailUpsertDto dto)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;

        // B-1b：本接口用 payload 的公司/工厂作为「物料/组件是否在范围内」的校验作用域，
        // 强制 stamp 会改变该作用域语义，故改为放行本租户组织、拒绝他租户组织。
        var orgError = await AdoS0OrgScope.ValidateOrgBelongsToTenantAsync(_rep.Context, tenantId, dto.CompanyRefId, dto.FactoryRefId);
        if (orgError != null) return orgError;
        var err = ValidateUpsert(dto);
        if (err != null) return BadRequest(new { message = err });

        // B1 + B2：Create 一律严格校验，禁止降级
        var matResult = await _refChecker.MaterialExistsInScopeAsync(tenantId, dto.MaterialCode, dto.CompanyRefId, dto.FactoryRefId);
        switch (matResult)
        {
            case MaterialScopeCheck.NotFound:
                return AdoS0ApiErrors.InvalidReference(AdoS0ErrorCodes.ReferenceNotFound,
                    $"物料编码 '{dto.MaterialCode}' 不存在于物料主数据");
            case MaterialScopeCheck.ScopeMiss:
                return AdoS0ApiErrors.InvalidReference(AdoS0ErrorCodes.InvalidReferenceScope,
                    $"物料编码 '{dto.MaterialCode}' 不属于当前公司/工厂 (CompanyRefId={dto.CompanyRefId}, FactoryRefId={dto.FactoryRefId})");
        }

        if (!await _refChecker.WorkCenterExistsAsync(tenantId, dto.WorkCenterCode))
            return AdoS0ApiErrors.InvalidReference(AdoS0ErrorCodes.ReferenceNotFound,
                $"工作中心编码 '{dto.WorkCenterCode}' 不存在于工作中心主数据");

        var entity = MapToEntity(dto);
        // 租户只由后端可信上下文赋值，忽略 DTO 中任何 tenant 相关入参。
        entity.TenantId = tenantId;
        entity.CreatedAt = DateTime.Now;
        await _rep.AsInsertable(entity).ExecuteReturnEntityAsync();
        return Ok(entity);
    }

    [HttpPut("{id:long}")]
    public async Task<IActionResult> UpdateAsync(long id, [FromBody] AdoS0MfgRoutingOpDetailUpsertDto dto)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;

        // B-1b：本接口用 payload 的公司/工厂作为「物料/组件是否在范围内」的校验作用域，
        // 强制 stamp 会改变该作用域语义，故改为放行本租户组织、拒绝他租户组织。
        var orgError = await AdoS0OrgScope.ValidateOrgBelongsToTenantAsync(_rep.Context, tenantId, dto.CompanyRefId, dto.FactoryRefId);
        if (orgError != null) return orgError;
        var err = ValidateUpsert(dto);
        if (err != null) return BadRequest(new { message = err });

        var entity = await _rep.ByIdScopedAsync(id, tenantId);
        if (entity == null) return NotFound();

        // ── LEGACY REFERENCE PRESERVATION（独立兼容合同，不改动下方 D-03 语义）─────────
        // UPDATE 时，若引用值与库中原值完全未变化，且影响该引用合法性的 scope 字段
        // 也完全未变化，则允许原值 preserve，跳过这一项的重新校验。
        // 任何被修改过的引用、以及 CREATE，一律走下方严格校验；
        // 底层 checker 语义保持不变（不在 checker 里「查不到就放行」）。
        //
        // 各引用的 scope 依据（按 AdoS0ReferenceChecker 实现推导，非猜测）：
        //   MaterialCode   -> MaterialExistsInScopeAsync(tenantId, itemNum, CompanyRefId, FactoryRefId)
        //                     故 scope 字段 = CompanyRefId + FactoryRefId
        //   WorkCenterCode -> WorkCenterExistsAsync(tenantId, workCenterCode)
        //                     只取 tenantId，UPDATE 中租户不可变 → 无额外 scope 字段
        //
        // 动机：91HC0497 那批历史行 scope 为 1000/1000，其物料主数据 scope 为 1000/8010，
        // 判定 ScopeMiss 而又不满足 D-03 的「原 scope 为 0/0」，导致即使什么都不改也无法保存；
        // ZJ01/ZJ02/ZJ03 同理不在 WorkCtrMaster 中。本豁免只允许「旧值 → 同一个旧值」。
        static string? Norm(string? v) => string.IsNullOrWhiteSpace(v) ? null : v.Trim();

        var scopeUnchanged = entity.CompanyRefId == dto.CompanyRefId && entity.FactoryRefId == dto.FactoryRefId;
        var materialPreserved = scopeUnchanged
            && string.Equals(Norm(entity.MaterialCode), Norm(dto.MaterialCode), StringComparison.Ordinal);
        var workCenterPreserved =
            string.Equals(Norm(entity.WorkCenterCode), Norm(dto.WorkCenterCode), StringComparison.Ordinal);

        if (materialPreserved)
        {
            _logger.LogInformation(
                "[LegacyRefPreserve] Table=RoutingOpDetail PrimaryKey={PrimaryKey} ReferenceField=MaterialCode " +
                "Value={Value} CompanyRefId={CompanyRefId} FactoryRefId={FactoryRefId} Reason=UnchangedValueAndScope",
                entity.Id, entity.MaterialCode, entity.CompanyRefId, entity.FactoryRefId);
        }

        // B1 + B2 + 历史兼容降级（D-03 严格条件）
        var matResult = materialPreserved
            ? MaterialScopeCheck.Match
            : await _refChecker.MaterialExistsInScopeAsync(tenantId, dto.MaterialCode, dto.CompanyRefId, dto.FactoryRefId);
        if (matResult == MaterialScopeCheck.NotFound)
            return AdoS0ApiErrors.InvalidReference(AdoS0ErrorCodes.ReferenceNotFound,
                $"物料编码 '{dto.MaterialCode}' 不存在于物料主数据");

        if (matResult == MaterialScopeCheck.ScopeMiss)
        {
            // 降级条件（全部满足才允许，对应 D-03 严格条件）：
            //   1. 是 Update（已满足）
            //   2. DB 原记录 scope 为 0/null/0
            //   3. 本次未修改 MaterialCode（dto 与 entity 相同）
            //   4. B1 存在性通过（matResult != NotFound，已满足）
            var originScopeEmpty = entity.CompanyRefId == 0 && entity.FactoryRefId == 0;
            var materialUnchanged = string.Equals(entity.MaterialCode, dto.MaterialCode?.Trim(), StringComparison.Ordinal);

            if (originScopeEmpty && materialUnchanged)
            {
                _logger.LogWarning(
                    "[B2 Downgrade] Table={TableName} PrimaryKey={PrimaryKey} ReferenceField={ReferenceField} " +
                    "OldValue={OldValue} NewValue={NewValue} CompanyRefId={CompanyRefId} FactoryRefId={FactoryRefId} " +
                    "DowngradeReason={DowngradeReason}",
                    "RoutingOpDetail", entity.Id, "MaterialCode",
                    entity.MaterialCode, dto.MaterialCode,
                    dto.CompanyRefId, dto.FactoryRefId,
                    "LegacyRecord_OriginScopeZero_MaterialUnchanged");
                // 放行，继续执行写入
            }
            else
            {
                return AdoS0ApiErrors.InvalidReference(AdoS0ErrorCodes.InvalidReferenceScope,
                    $"物料编码 '{dto.MaterialCode}' 不属于当前公司/工厂 (CompanyRefId={dto.CompanyRefId}, FactoryRefId={dto.FactoryRefId})");
            }
        }

        // 工作中心：值未变化即 preserve（scope 仅 tenantId，UPDATE 中不可变）；
        // 改成任何其它值仍必须通过 WorkCenterExistsAsync。
        if (workCenterPreserved)
        {
            if (!string.IsNullOrWhiteSpace(entity.WorkCenterCode))
                _logger.LogInformation(
                    "[LegacyRefPreserve] Table=RoutingOpDetail PrimaryKey={PrimaryKey} ReferenceField=WorkCenterCode " +
                    "Value={Value} Reason=UnchangedValue",
                    entity.Id, entity.WorkCenterCode);
        }
        else if (!await _refChecker.WorkCenterExistsAsync(tenantId, dto.WorkCenterCode))
        {
            return AdoS0ApiErrors.InvalidReference(AdoS0ErrorCodes.ReferenceNotFound,
                $"工作中心编码 '{dto.WorkCenterCode}' 不存在于工作中心主数据");
        }

        ApplyUpsert(entity, dto);
        entity.UpdatedAt = DateTime.Now;
        await _rep.AsUpdateable(entity).ExecuteCommandAsync();
        return Ok(entity);
    }

    [HttpPatch("{id:long}/toggle-enabled")]
    public async Task<IActionResult> ToggleEnabledAsync(long id, [FromBody] AdoS0ToggleEnabledDto dto)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var entity = await _rep.ByIdScopedAsync(id, tenantId);
        if (entity == null) return NotFound();
        entity.IsEnabled = dto.IsEnabled;
        entity.UpdatedAt = DateTime.Now;
        await _rep.AsUpdateable(entity).ExecuteCommandAsync();
        return Ok(entity);
    }

    [HttpDelete("{id:long}")]
    public async Task<IActionResult> DeleteAsync(long id)
    {
        if (!AdoS0TenantScope.TryResolveRequired(out var tenantId, out var tenantError)) return tenantError!;
        var item = await _rep.ByIdScopedAsync(id, tenantId);
        if (item == null) return NotFound();
        await _rep.DeleteAsync(item);
        return Ok(new { message = "删除成功" });
    }

    private static string? ValidateUpsert(AdoS0MfgRoutingOpDetailUpsertDto dto)
    {
        if (string.IsNullOrWhiteSpace(dto.RouteCode)) return "工艺路线编码不能为空";
        if (string.IsNullOrWhiteSpace(dto.RouteName)) return "工艺路线名称不能为空";
        if (string.IsNullOrWhiteSpace(dto.MaterialCode)) return "物料编码不能为空";
        if (string.IsNullOrWhiteSpace(dto.OperationCode)) return "工序编码不能为空";
        return null;
    }

    private static AdoS0MfgRoutingOpDetail MapToEntity(AdoS0MfgRoutingOpDetailUpsertDto dto)
    {
        var e = new AdoS0MfgRoutingOpDetail();
        ApplyUpsert(e, dto);
        return e;
    }

    private static void ApplyUpsert(AdoS0MfgRoutingOpDetail e, AdoS0MfgRoutingOpDetailUpsertDto dto)
    {
        e.CompanyRefId = dto.CompanyRefId;
        e.FactoryRefId = dto.FactoryRefId;
        e.RouteCode = dto.RouteCode.Trim();
        e.RouteName = dto.RouteName.Trim();
        e.MaterialCode = dto.MaterialCode.Trim();
        e.OperationCode = dto.OperationCode.Trim();
        e.OperationDescription = (dto.OperationDescription ?? string.Empty).Trim();
        e.WorkCenterCode = (dto.WorkCenterCode ?? string.Empty).Trim();
        e.MilestoneOperation = string.IsNullOrWhiteSpace(dto.MilestoneOperation) ? null : dto.MilestoneOperation.Trim();
        e.Ufld1 = dto.Ufld1;
        e.Ufld2 = dto.Ufld2;
        e.UDeci1 = dto.UDeci1;
        e.Ufld3 = dto.Ufld3;
        e.Ufld4 = dto.Ufld4;
        e.Ufld5 = dto.Ufld5;
        e.UDeci2 = dto.UDeci2;
        e.Ufld6 = dto.Ufld6;
        e.Ufld7 = dto.Ufld7;
        e.Ufld8 = dto.Ufld8;
        e.UDeci3 = dto.UDeci3;
        e.Ufld9 = dto.Ufld9;
        e.UDeci4 = dto.UDeci4;
        e.UDeci5 = dto.UDeci5;
        e.SupplierCode = string.IsNullOrWhiteSpace(dto.SupplierCode) ? null : dto.SupplierCode.Trim();
        e.OutsourcedLeadTime = dto.OutsourcedLeadTime;
        e.SortNo = dto.SortNo;
        e.IsEnabled = dto.IsEnabled;
        e.IsConfirm = dto.IsConfirm;
        e.CommentIndex = dto.CommentIndex;
        e.CreateUser = dto.CreateUser;
        e.UpdateUser = dto.UpdateUser;
    }
}