AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/SmartOps/SmartOpsImprovementActionService.cs

using System.Text.Json;
using Admin.NET.Core;
using Admin.NET.Core.Service;
using Admin.NET.Plugin.AiDOP.Controllers;
using Admin.NET.Plugin.AiDOP.Entity;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using Microsoft.Extensions.Logging;

namespace Admin.NET.Plugin.AiDOP.SmartOps;

public sealed class SmartOpsImprovementActionService : ITransient
{
    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        PropertyNameCaseInsensitive = true,
    };

    private readonly ISqlSugarClient _db;
    private readonly SysNoticeService _noticeService;
    private readonly ILogger<SmartOpsImprovementActionService> _logger;

    public SmartOpsImprovementActionService(
        ISqlSugarClient db,
        SysNoticeService noticeService,
        ILogger<SmartOpsImprovementActionService> logger)
    {
        _db = db;
        _noticeService = noticeService;
        _logger = logger;
    }

    public async Task<List<AdoSmartOpsImprovementAction>> ListByPlanAsync(long tenantId, long planId)
    {
        await MigrateLegacyJsonAsync(tenantId, planId);
        return await _db.Queryable<AdoSmartOpsImprovementAction>()
            .Where(x => x.TenantId == tenantId && x.PlanId == planId)
            .OrderBy(x => x.SequenceNo)
            .ToListAsync();
    }

    public async Task<List<AdoSmartOpsImprovementAction>> ListMineAsync(SmartOpsTrustedScope scope)
    {
        return await _db.Queryable<AdoSmartOpsImprovementAction>()
            .InnerJoin<AdoSmartOpsImprovementPlan>((a, p) => a.PlanId == p.Id && a.TenantId == p.TenantId)
            .Where((a, p) => a.TenantId == scope.TenantId && a.OwnerUserId == scope.UserId)
            .Where((a, p) => p.Status == "executing" || p.Status == "pending_verify")
            .OrderBy((a, p) => a.DueDate)
            .Select((a, p) => a)
            .ToListAsync();
    }

    public async Task NotifyAssignedForPlanAsync(AdoSmartOpsImprovementPlan plan, long operatorUserId)
    {
        var rows = await _db.Queryable<AdoSmartOpsImprovementAction>()
            .Where(x => x.TenantId == plan.TenantId && x.PlanId == plan.Id && x.OwnerUserId > 0)
            .ToListAsync();
        foreach (var row in rows)
            await NotifyAsync(plan, row, SmartOpsImprovementNoticeType.Assigned, operatorUserId);
    }

    public async Task NotifyOwnerToStartAsync(AdoSmartOpsImprovementPlan plan, long operatorUserId)
    {
        if (plan.OwnerUserId is not > 0) return;
        var jump = $"/#/aidop/smart-ops/improvement-plans?id={plan.Id}";
        var content =
            $"<p>改善计划 {plan.PlanNo} 已审批通过，请作为总负责人开始执行。开始后系统会把各行动项分派给对应责任人。</p>" +
            $"<p><a href=\"{jump}\">打开计划详情</a></p>";
        try
        {
            await _noticeService.PublishToUsersAsync(
                $"改善计划待开始执行 {plan.PlanNo}",
                content,
                new[] { plan.OwnerUserId.Value },
                operatorUserId > 0 ? operatorUserId : plan.OwnerUserId.Value,
                "智慧诊断");
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "改善计划开始执行通知失败 planId={PlanId}", plan.Id);
        }
    }

    public async Task<long?> ResolveOwnerUserIdAsync(AdoSmartOpsImprovementPlan plan)
    {
        if (plan.OwnerUserId is > 0) return plan.OwnerUserId;
        var first = await _db.Queryable<AdoSmartOpsImprovementAction>()
            .Where(x => x.TenantId == plan.TenantId && x.PlanId == plan.Id && x.OwnerUserId > 0)
            .OrderBy(x => x.SequenceNo)
            .FirstAsync();
        return first?.OwnerUserId;
    }

    public async Task ReplaceFromDraftAsync(
        AdoSmartOpsImprovementPlan plan,
        IReadOnlyList<ImprovementActionItem> drafts,
        SmartOpsTrustedScope scope)
    {
        var existing = await _db.Queryable<AdoSmartOpsImprovementAction>()
            .Where(x => x.TenantId == plan.TenantId && x.PlanId == plan.Id)
            .ToListAsync();
        if (existing.Count > 0)
            return;

        var now = DateTime.Now;
        var rows = new List<AdoSmartOpsImprovementAction>();
        for (var i = 0; i < drafts.Count; i++)
        {
            var draft = drafts[i];
            if (string.IsNullOrWhiteSpace(draft.Content)) continue;
            var ownerUserId = draft.OwnerUserId is > 0 ? draft.OwnerUserId : null;
            if (ownerUserId is > 0)
                await EnsureOwnerInTenantAsync(plan.TenantId ?? 0, ownerUserId);
            rows.Add(new AdoSmartOpsImprovementAction
            {
                TenantId = plan.TenantId,
                FactoryId = plan.FactoryId,
                PlanId = plan.Id,
                SequenceNo = rows.Count + 1,
                Content = draft.Content.Trim(),
                OwnerUserId = ownerUserId,
                OwnerName = draft.Owner,
                DueDate = ParseDate(draft.DueDate),
                Status = SmartOpsImprovementActionStatus.Pending,
                CompletedAt = null,
                Version = 1,
                CreateUserId = scope.UserId,
                UpdateUserId = scope.UserId,
                CreateTime = now,
                UpdateTime = now,
            });
        }
        if (rows.Count == 0) return;
        await _db.Insertable(rows).ExecuteCommandAsync();
        var persisted = await _db.Queryable<AdoSmartOpsImprovementAction>()
            .Where(x => x.TenantId == plan.TenantId && x.PlanId == plan.Id)
            .OrderBy(x => x.SequenceNo)
            .ToListAsync();
        foreach (var row in persisted)
            await WriteLogAsync(row, "create", null, row, scope.UserId, "从诊断创建");
    }

    public async Task<AdoSmartOpsImprovementAction> MutateAsync(
        long planId,
        int? sequenceNo,
        long? actionId,
        string? status,
        string? completedAt,
        long? ownerUserId,
        string? ownerName,
        string? proofRemark,
        SmartOpsTrustedScope scope)
    {
        var plan = await _db.Queryable<AdoSmartOpsImprovementPlan>()
            .FirstAsync(x => x.Id == planId && x.TenantId == scope.TenantId)
            ?? throw Oops.Oh("改善计划不存在");
        await MigrateLegacyJsonAsync(scope.TenantId, plan.Id);

        AdoSmartOpsImprovementAction? action = null;
        if (actionId is > 0)
        {
            action = await _db.Queryable<AdoSmartOpsImprovementAction>()
                .FirstAsync(x => x.Id == actionId && x.TenantId == scope.TenantId && x.PlanId == plan.Id);
        }
        else if (sequenceNo is > 0)
        {
            action = await _db.Queryable<AdoSmartOpsImprovementAction>()
                .FirstAsync(x => x.TenantId == scope.TenantId && x.PlanId == plan.Id && x.SequenceNo == sequenceNo);
        }
        if (action == null) throw Oops.Oh("行动项不存在");
        EnsureCanMutate(plan, action, scope);

        var before = Snapshot(action);
        var previousOwnerUserId = action.OwnerUserId;
        var nextStatus = string.IsNullOrWhiteSpace(status)
            ? action.Status
            : SmartOpsImprovementActionStatus.Normalize(status);
        if (!SmartOpsImprovementActionStatus.CanTransition(action.Status, nextStatus))
            throw Oops.Oh($"行动项不能从 {action.Status} 变更为 {nextStatus}");

        if (ownerUserId.HasValue)
        {
            if (ownerUserId > 0)
                await EnsureOwnerInTenantAsync(scope.TenantId, ownerUserId);
            action.OwnerUserId = ownerUserId > 0 ? ownerUserId : null;
        }
        if (ownerName != null) action.OwnerName = ownerName;
        if (proofRemark != null) action.ProofRemark = proofRemark;
        var statusChanged = !string.Equals(action.Status, nextStatus, StringComparison.OrdinalIgnoreCase);
        var assigned = ownerUserId is > 0 && ownerUserId != previousOwnerUserId;
        action.Status = nextStatus;
        action.CompletedAt = nextStatus == SmartOpsImprovementActionStatus.Completed
            ? ParseDate(completedAt) ?? DateTime.Today
            : null;
        action.Version += 1;
        action.UpdateUserId = scope.UserId;
        action.UpdateTime = DateTime.Now;

        await _db.Updateable(action)
            .Where(x => x.Id == action.Id && x.TenantId == scope.TenantId && x.Version == action.Version - 1)
            .ExecuteCommandAsync();
        await WriteLogAsync(action, statusChanged ? "status" : "update", before, action, scope.UserId, proofRemark);
        if (assigned && (plan.Status == "executing" || plan.Status == "pending_verify"))
            await NotifyAsync(plan, action, SmartOpsImprovementNoticeType.Assigned, scope.UserId);
        else if (statusChanged)
            await NotifyAsync(plan, action, SmartOpsImprovementNoticeType.StatusChanged, scope.UserId);
        return action;
    }

    public async Task<List<AdoSmartOpsImprovementActionLog>> ListLogsAsync(long tenantId, long actionId)
    {
        return await _db.Queryable<AdoSmartOpsImprovementActionLog>()
            .Where(x => x.TenantId == tenantId && x.ActionId == actionId)
            .OrderByDescending(x => x.CreateTime)
            .ToListAsync();
    }

    public async Task MigrateLegacyJsonAsync(long tenantId, long? planId = null)
    {
        var q = _db.Queryable<AdoSmartOpsImprovementPlan>()
            .Where(x => x.TenantId == tenantId && !string.IsNullOrWhiteSpace(x.ActionItemsJson));
        if (planId is > 0) q = q.Where(x => x.Id == planId);
        var plans = await q.ToListAsync();
        foreach (var plan in plans)
        {
            var exists = await _db.Queryable<AdoSmartOpsImprovementAction>()
                .AnyAsync(x => x.TenantId == tenantId && x.PlanId == plan.Id);
            if (exists) continue;
            var drafts = ParseDrafts(plan.ActionItemsJson);
            if (drafts.Count == 0) continue;
            await ReplaceFromDraftAsync(plan, drafts, new SmartOpsTrustedScope(tenantId, plan.FactoryId, plan.OwnerUserId ?? 0));
        }
    }

    public static List<ImprovementActionItem> ToLegacyItems(IEnumerable<AdoSmartOpsImprovementAction> actions)
    {
        return actions.Select(x => new ImprovementActionItem
        {
            Content = x.Content,
            Owner = x.OwnerName,
            DueDate = x.DueDate?.ToString("yyyy-MM-dd"),
            Status = SmartOpsImprovementActionStatus.DisplayStatus(x.Status, x.DueDate, DateTime.Today),
            CompletedAt = x.CompletedAt?.ToString("yyyy-MM-dd"),
        }).ToList();
    }

    public static object ToApiItem(AdoSmartOpsImprovementAction x) => new
    {
        x.Id,
        x.SequenceNo,
        x.Content,
        Owner = x.OwnerName,
        x.OwnerUserId,
        DueDate = x.DueDate?.ToString("yyyy-MM-dd"),
        Status = SmartOpsImprovementActionStatus.DisplayStatus(x.Status, x.DueDate, DateTime.Today),
        CompletedAt = x.CompletedAt?.ToString("yyyy-MM-dd"),
        x.ProofRemark,
        Overdue = SmartOpsImprovementActionStatus.IsOverdue(x.Status, x.DueDate, DateTime.Today),
    };

    /// <summary>整单到期日：有内容的行动项里，完成日期最晚的一天。</summary>
    internal static DateTime? ResolveLatestDueDate(IEnumerable<ImprovementActionItem>? drafts)
    {
        DateTime? max = null;
        if (drafts == null) return null;
        foreach (var draft in drafts)
        {
            if (string.IsNullOrWhiteSpace(draft.Content)) continue;
            var parsed = ParseDate(draft.DueDate);
            if (parsed == null) continue;
            if (max == null || parsed > max) max = parsed;
        }
        return max;
    }

    internal static List<ImprovementActionItem> ParseDrafts(string? json)
    {
        if (string.IsNullOrWhiteSpace(json)) return new List<ImprovementActionItem>();
        try
        {
            return JsonSerializer.Deserialize<List<ImprovementActionItem>>(json, JsonOptions)
                   ?? new List<ImprovementActionItem>();
        }
        catch
        {
            return new List<ImprovementActionItem>();
        }
    }

    private static void EnsureCanMutate(
        AdoSmartOpsImprovementPlan plan,
        AdoSmartOpsImprovementAction action,
        SmartOpsTrustedScope scope)
    {
        if (scope.UserId > 0 && scope.UserId == action.OwnerUserId) return;
        if (scope.UserId > 0 && scope.UserId == action.CreateUserId) return;
        if (scope.UserId > 0 && plan.OwnerUserId is > 0 && scope.UserId == plan.OwnerUserId) return;
        throw Oops.Oh("无权修改该行动项");
    }

    private async Task WriteLogAsync(
        AdoSmartOpsImprovementAction action,
        string operation,
        object? before,
        object after,
        long operatorUserId,
        string? remark)
    {
        await _db.Insertable(new AdoSmartOpsImprovementActionLog
        {
            TenantId = action.TenantId,
            ActionId = action.Id,
            PlanId = action.PlanId,
            Operation = operation,
            BeforeJson = before == null ? null : JsonSerializer.Serialize(before, JsonOptions),
            AfterJson = JsonSerializer.Serialize(Snapshot(action), JsonOptions),
            OperatorUserId = operatorUserId,
            Remark = remark,
            CreateTime = DateTime.Now,
        }).ExecuteCommandAsync();
    }

    private async Task NotifyAsync(
        AdoSmartOpsImprovementPlan plan,
        AdoSmartOpsImprovementAction action,
        string noticeType,
        long operatorUserId)
    {
        if (action.OwnerUserId is not > 0) return;
        var today = DateTime.Today;
        var claimed = await TryClaimNoticeAsync(action.TenantId ?? 0, action.Id, noticeType, today);
        if (!claimed) return;

        var title = noticeType switch
        {
            SmartOpsImprovementNoticeType.Assigned => "改善任务已分派",
            SmartOpsImprovementNoticeType.DueSoon => "改善任务即将到期",
            SmartOpsImprovementNoticeType.Overdue => "改善任务已逾期",
            _ => "改善任务状态变更",
        };
        var due = action.DueDate?.ToString("yyyy-MM-dd") ?? "-";
        var jump = $"/#/aidop/smart-ops/improvement-plans?id={plan.Id}&actionId={action.Id}";
        var content =
            $"<p>计划 {plan.PlanNo} 行动项#{action.SequenceNo}：{action.Content}。到期日 {due}。</p>" +
            $"<p><a href=\"{jump}\">查看任务详情</a></p>";
        long noticeId = 0;
        try
        {
            noticeId = await _noticeService.PublishToUsersAsync(
                title,
                content,
                new[] { action.OwnerUserId.Value },
                operatorUserId > 0 ? operatorUserId : action.OwnerUserId.Value,
                "智慧诊断");
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "改善行动项通知发布失败 actionId={ActionId} type={Type}", action.Id, noticeType);
        }
        if (noticeId > 0)
        {
            await _db.Updateable<AdoSmartOpsImprovementActionNotice>()
                .SetColumns(x => x.NoticeId == noticeId)
                .Where(x => x.TenantId == action.TenantId && x.ActionId == action.Id
                            && x.NoticeType == noticeType && x.NoticeDate == today)
                .ExecuteCommandAsync();
        }
    }

    public async Task<int> SendDueRemindersAsync(ISqlSugarClient db, long tenantId, DateTime today)
    {
        var actions = await db.Queryable<AdoSmartOpsImprovementAction>()
            .Where(x => x.TenantId == tenantId && x.OwnerUserId > 0 && x.DueDate != null)
            .Where(x => x.Status == SmartOpsImprovementActionStatus.Pending
                        || x.Status == SmartOpsImprovementActionStatus.InProgress)
            .ToListAsync();
        var sent = 0;
        foreach (var action in actions)
        {
            var plan = await db.Queryable<AdoSmartOpsImprovementPlan>()
                .FirstAsync(x => x.Id == action.PlanId && x.TenantId == tenantId);
            if (plan == null) continue;
            var due = action.DueDate!.Value.Date;
            string? type = null;
            if (due < today) type = SmartOpsImprovementNoticeType.Overdue;
            else if (due <= today.AddDays(1)) type = SmartOpsImprovementNoticeType.DueSoon;
            if (type == null) continue;
            try
            {
                await NotifyAsync(plan, action, type, action.OwnerUserId ?? 0);
                sent++;
            }
            catch
            {
                // Keep scanning remaining tenants/actions.
            }
        }
        return sent;
    }

    private async Task<bool> TryClaimNoticeAsync(long tenantId, long actionId, string noticeType, DateTime date)
    {
        try
        {
            await _db.Insertable(new AdoSmartOpsImprovementActionNotice
            {
                TenantId = tenantId,
                ActionId = actionId,
                NoticeType = noticeType,
                NoticeDate = date.Date,
                CreateTime = DateTime.Now,
            }).ExecuteCommandAsync();
            return true;
        }
        catch (Exception ex) when (ex.Message.Contains("Duplicate", StringComparison.OrdinalIgnoreCase)
                                   || ex.InnerException?.Message.Contains("Duplicate", StringComparison.OrdinalIgnoreCase) == true)
        {
            return false;
        }
    }

    private static object Snapshot(AdoSmartOpsImprovementAction x) => new
    {
        x.Id,
        x.SequenceNo,
        x.Content,
        Owner = x.OwnerName,
        x.OwnerUserId,
        x.Status,
        DueDate = x.DueDate?.ToString("yyyy-MM-dd"),
        CompletedAt = x.CompletedAt?.ToString("yyyy-MM-dd"),
        x.Version,
    };

    private async Task EnsureOwnerInTenantAsync(long tenantId, long? ownerUserId)
    {
        if (ownerUserId is not > 0 || tenantId <= 0) return;
        var ok = await _db.Queryable<SysUser>().ClearFilter<ITenantIdFilter>()
            .AnyAsync(x => x.Id == ownerUserId && x.TenantId == tenantId);
        if (!ok)
            throw Oops.Oh("责任人不是当前租户的有效用户");
    }

    private static DateTime? ParseDate(string? raw) =>
        DateTime.TryParse(raw, out var value) ? value.Date : null;
}