AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Infrastructure/AidopTenantInitService.cs

using Admin.NET.Plugin.AiDOP.Entity;
using Furion.Logging;
using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Service.S8.OrderFlow;
using Yitter.IdGenerator;

namespace Admin.NET.Plugin.AiDOP.Infrastructure;

/// <summary>
/// Ai-DOP 每租户必备基线：S8 七个业务角色 + KPI calc config（从 AIDOP 模板租户复制）。
/// 形态为「每租户复制」，便于各租户独立调整 KPI 公式与角色配置。
/// </summary>
public sealed class AidopTenantInitService : ITransient
{
    /// <summary>AIDOP 运行租户：KPI calc config 模板来源。</summary>
    public const long KpiTemplateTenantId = 797403760988229L;
    /// <summary>AIDOPDemo：S8 七模块场景模板来源，不含规则、数据源或凭据。</summary>
    public const long S8SceneTemplateTenantId = 797403760988230L;

    // S8-CFG-NOTIFY-NONDEFAULT-ROLE-OPTIONS-FIX-1：改引用 canonical 单一来源。
    // 原先此处与 S8SysRoleSeedData 各存一份逐字相同的字面量，靠人工同步；
    // role-options 若再复制第三份必然分叉，故统一收口到 S8CanonicalRole。内容未变。
    private static (string Code, string Name, int OrderNo)[] S8BusinessRoles
        => Admin.NET.Plugin.AiDOP.Infrastructure.S8.S8CanonicalRole.BusinessRoles;

    private readonly ISqlSugarClient _db;

    public AidopTenantInitService(ISqlSugarClient db) => _db = db;

    /// <summary>幂等种入目标租户的 S8 业务角色、KPI 主数据/布局与 calc config；允许重复调用。</summary>
    public async Task<AidopTenantBaselineResult> InitTenantBaselineAsync(long tenantId)
    {
        if (tenantId <= 0)
            return new AidopTenantBaselineResult();

        var s8Roles = await SeedS8BusinessRolesAsync(tenantId);
        var approvalRoles = await CountInsertedAsync(
            () => CountRolesAsync(tenantId, SmartOpsImprovementApprovalRules.BaselineRoles.Select(x => x.Code)),
            () => AidopImprovementApprovalSeed.EnsureBaselineRoles(_db, tenantId));
        var scenes = await SeedS8ScenesFromTemplateAsync(tenantId);
        var kpiMasters = await CountInsertedAsync(
            () => _db.Queryable<AdoSmartOpsKpiMaster>().ClearFilter<ITenantIdFilter>().CountAsync(x => x.TenantId == tenantId),
            () => AidopKpiMasterSeed.EnsureSeed(_db, tenantId, includeDemoValues: false));
        var kpiCalc = await SeedKpiCalcConfigFromTemplateAsync(tenantId);

        var result = new AidopTenantBaselineResult
        {
            S8Roles = s8Roles,
            ApprovalRoles = approvalRoles,
            Scenes = scenes,
            KpiMasters = kpiMasters,
            KpiCalcConfigs = kpiCalc,
        };
        Log.Information(
            "租户基线 tenant={TenantId} s8Roles={S8Roles} approvalRoles={ApprovalRoles} scenes={Scenes} kpiMasters={KpiMasters} kpiCalc={KpiCalc}",
            tenantId, result.S8Roles, result.ApprovalRoles, result.Scenes, result.KpiMasters, result.KpiCalcConfigs);
        return result;
    }

    private async Task<int> CountInsertedAsync(Func<Task<int>> count, Action seed)
    {
        var before = await count();
        seed();
        var after = await count();
        return Math.Max(0, after - before);
    }

    private async Task<int> SeedS8ScenesFromTemplateAsync(long tenantId)
    {
        if (tenantId == S8SceneTemplateTenantId) return 0;

        var factoryId = await _db.Queryable<SysTenant>()
            .ClearFilter<ITenantIdFilter>()
            .Where(x => x.Id == tenantId)
            .Select(x => x.OrgId)
            .FirstAsync();
        if (factoryId <= 0) return 0;

        var templates = await _db.Queryable<AdoS8SceneConfig>()
            .ClearFilter<ITenantIdFilter>()
            .Where(x => x.TenantId == S8SceneTemplateTenantId && x.Enabled)
            .OrderBy(x => x.SortNo)
            .ToListAsync();
        var now = DateTime.Now;
        var inserted = 0;
        foreach (var template in templates)
        {
            var exists = await _db.Queryable<AdoS8SceneConfig>()
                .ClearFilter<ITenantIdFilter>()
                .AnyAsync(x => x.TenantId == tenantId
                            && x.FactoryId == factoryId
                            && x.SceneCode == template.SceneCode);
            if (exists) continue;

            inserted++;
            await _db.Insertable(new AdoS8SceneConfig
            {
                TenantId = tenantId,
                FactoryId = factoryId,
                SceneCode = template.SceneCode,
                SceneName = template.SceneName,
                Enabled = true,
                SortNo = template.SortNo,
                CreatedAt = now,
            }).ExecuteCommandAsync();
        }
        return inserted;
    }

    private async Task<int> SeedS8BusinessRolesAsync(long tenantId)
    {
        var ct = DateTime.Now;
        var inserted = 0;
        foreach (var (code, name, orderNo) in S8BusinessRoles)
        {
            var exists = await _db.Queryable<SysRole>()
                .ClearFilter<ITenantIdFilter>()
                .AnyAsync(r => r.TenantId == tenantId && r.Code == code);
            if (exists) continue;

            inserted++;
            await _db.Insertable(new SysRole
            {
                Id = YitIdHelper.NextId(),
                TenantId = tenantId,
                Name = name,
                Code = code,
                OrderNo = orderNo,
                DataScope = DataScopeEnum.Self,
                Status = StatusEnum.Enable,
                Remark = "S8 业务角色（异常协同承接）",
                CreateTime = ct,
            }).ExecuteCommandAsync();
        }
        return inserted;
    }

    private async Task<int> SeedKpiCalcConfigFromTemplateAsync(long tenantId)
    {
        if (tenantId == KpiTemplateTenantId) return 0;

        var templates = await _db.Queryable<AdoSmartOpsKpiCalcConfig>()
            .ClearFilter<ITenantIdFilter>()
            .Where(c => c.TenantId == KpiTemplateTenantId)
            .ToListAsync();
        if (templates.Count == 0) return 0;

        var now = DateTime.Now;
        var inserted = 0;
        foreach (var tpl in templates)
        {
            var exists = await _db.Queryable<AdoSmartOpsKpiCalcConfig>()
                .ClearFilter<ITenantIdFilter>()
                .AnyAsync(c => c.TenantId == tenantId && c.MetricCode == tpl.MetricCode && c.VersionNo == tpl.VersionNo);
            if (exists) continue;

            inserted++;
            await _db.Insertable(new AdoSmartOpsKpiCalcConfig
            {
                TenantId = tenantId,
                MetricCode = tpl.MetricCode,
                ModuleCode = tpl.ModuleCode,
                VersionNo = tpl.VersionNo,
                CalcEngineType = tpl.CalcEngineType,
                DataSourceCode = tpl.DataSourceCode,
                SqlScript = tpl.SqlScript,
                SqlParametersJson = tpl.SqlParametersJson,
                TimeoutSeconds = tpl.TimeoutSeconds,
                PublishStatus = tpl.PublishStatus,
                IsCurrent = tpl.IsCurrent,
                Remark = tpl.Remark,
                CreatedBy = "AidopTenantInit",
                CreatedAt = now,
            }).ExecuteCommandAsync();
        }
        return inserted;
    }

    private Task<int> CountRolesAsync(long tenantId, IEnumerable<string> codes)
    {
        var list = codes.Where(c => !string.IsNullOrWhiteSpace(c)).Distinct().ToList();
        if (list.Count == 0) return Task.FromResult(0);
        return _db.Queryable<SysRole>()
            .ClearFilter<ITenantIdFilter>()
            .CountAsync(r => r.TenantId == tenantId && list.Contains(r.Code));
    }
}

/// <summary>一次基线执行实际新写入的条数。重复调用时各项为 0。</summary>
public sealed class AidopTenantBaselineResult
{
    public int S8Roles { get; init; }
    public int ApprovalRoles { get; init; }
    public int Scenes { get; init; }
    public int KpiMasters { get; init; }
    public int KpiCalcConfigs { get; init; }
}