Add domestic vendor push infrastructure

2026-07-26 01:45:59 +08:00
parent 7cca34b331
commit 0738953e6d
77 changed files with 6470 additions and 855 deletions
@@ -0,0 +1,326 @@
+using MiaoJiZhang.Api.Contracts;
+using MiaoJiZhang.Api.Services;
+using MiaoJiZhang.Domain.Entities;
+using MiaoJiZhang.Infrastructure.Persistence;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace MiaoJiZhang.Api.Controllers;
+
+[ApiController]
+[AdminAuth]
+[Route("api/admin/push")]
+public class AdminPushController(
+    AppDbContext db,
+    PushProviderRegistry providers,
+    IConfiguration configuration) : ControllerBase
+{
+    [HttpGet("campaigns")]
+    public async Task<IActionResult> Campaigns(
+        [FromQuery] int page = 1,
+        [FromQuery] int limit = 20,
+        CancellationToken ct = default)
+    {
+        page = Math.Max(1, page);
+        limit = Math.Clamp(limit, 1, 100);
+        var query = db.PushMessages.AsNoTracking().Where(message => message.Source == "admin");
+        var total = await query.CountAsync(ct);
+        var messages = await query.OrderByDescending(message => message.CreatedAt)
+            .Skip((page - 1) * limit).Take(limit).ToListAsync(ct);
+        var ids = messages.Select(message => message.Id).ToList();
+        var counts = await db.PushDeliveries.Where(delivery => ids.Contains(delivery.PushMessageId))
+            .GroupBy(delivery => new { delivery.PushMessageId, delivery.State })
+            .Select(group => new { group.Key.PushMessageId, group.Key.State, Count = group.Count() })
+            .ToListAsync(ct);
+        return Ok(new
+        {
+            total,
+            page,
+            list = messages.Select(message => ToDto(message, counts
+                .Where(item => item.PushMessageId == message.Id)
+                .ToDictionary(item => item.State, item => item.Count))),
+        });
+    }
+
+    [HttpPost("campaigns/estimate")]
+    public async Task<IActionResult> Estimate(CreatePushCampaignRequest request, CancellationToken ct)
+    {
+        var error = Validate(request);
+        if (error is not null) return BadRequest(error);
+        var count = await EligibleDevices(request).CountAsync(ct);
+        return Ok(new { devices = count });
+    }
+
+    [HttpPost("campaigns")]
+    public async Task<IActionResult> Create(CreatePushCampaignRequest request, CancellationToken ct)
+    {
+        var error = Validate(request);
+        if (error is not null) return BadRequest(error);
+        if (request.TargetUserId.HasValue &&
+            !await db.Users.AnyAsync(user => user.Id == request.TargetUserId.Value, ct))
+            return BadRequest(new ApiError("PUSH_TARGET_INVALID", "目标用户不存在"));
+
+        var now = DateTime.UtcNow;
+        var message = Map(request, new PushMessage
+        {
+            PublicId = Guid.NewGuid().ToString(),
+            Source = "admin",
+            State = PushMessageStates.Draft,
+            CreatedAt = now,
+        }, now);
+        db.PushMessages.Add(message);
+        await db.SaveChangesAsync(ct);
+        return Ok(ToDto(message, new Dictionary<string, int>()));
+    }
+
+    [HttpPut("campaigns/{id:long}")]
+    public async Task<IActionResult> Update(long id, CreatePushCampaignRequest request, CancellationToken ct)
+    {
+        var error = Validate(request);
+        if (error is not null) return BadRequest(error);
+        if (request.TargetUserId.HasValue &&
+            !await db.Users.AnyAsync(user => user.Id == request.TargetUserId.Value, ct))
+            return BadRequest(new ApiError("PUSH_TARGET_INVALID", "目标用户不存在"));
+        var message = await db.PushMessages.FirstOrDefaultAsync(item => item.Id == id && item.Source == "admin", ct);
+        if (message is null) return NotFound();
+        if (message.State is not (PushMessageStates.Draft or PushMessageStates.Scheduled))
+            return Conflict(new ApiError("PUSH_CAMPAIGN_LOCKED", "推送已开始发送，不能再编辑"));
+        Map(request, message, DateTime.UtcNow);
+        await db.SaveChangesAsync(ct);
+        return Ok(ToDto(message, new Dictionary<string, int>()));
+    }
+
+    [HttpPost("campaigns/{id:long}/send")]
+    public async Task<IActionResult> Send(
+        long id,
+        SchedulePushCampaignRequest request,
+        CancellationToken ct)
+    {
+        var message = await db.PushMessages.FirstOrDefaultAsync(item => item.Id == id && item.Source == "admin", ct);
+        if (message is null) return NotFound();
+        if (message.State is not (PushMessageStates.Draft or PushMessageStates.Scheduled))
+            return Conflict(new ApiError("PUSH_CAMPAIGN_LOCKED", "推送已开始发送或已经结束"));
+
+        var now = DateTime.UtcNow;
+        var scheduledAt = request.ScheduledAt?.ToUniversalTime();
+        message.ScheduledAt = scheduledAt;
+        message.State = scheduledAt.HasValue && scheduledAt.Value > now.AddSeconds(5)
+            ? PushMessageStates.Scheduled
+            : PushMessageStates.Queued;
+        message.UpdatedAt = now;
+        await db.SaveChangesAsync(ct);
+        return Ok(ToDto(message, new Dictionary<string, int>()));
+    }
+
+    [HttpPost("campaigns/{id:long}/cancel")]
+    public async Task<IActionResult> Cancel(long id, CancellationToken ct)
+    {
+        var now = DateTime.UtcNow;
+        var cancelled = await db.PushMessages
+            .Where(message => message.Id == id && message.Source == "admin" &&
+                (message.State == PushMessageStates.Draft ||
+                 message.State == PushMessageStates.Scheduled ||
+                 message.State == PushMessageStates.Queued) &&
+                message.StartedAt == null)
+            .ExecuteUpdateAsync(setters => setters
+                .SetProperty(message => message.State, PushMessageStates.Cancelled)
+                .SetProperty(message => message.CancelledAt, now)
+                .SetProperty(message => message.UpdatedAt, now), ct);
+        if (cancelled != 1)
+        {
+            var exists = await db.PushMessages.AnyAsync(
+                message => message.Id == id && message.Source == "admin", ct);
+            return exists
+                ? Conflict(new ApiError("PUSH_CAMPAIGN_LOCKED", "推送已经开始，不能取消"))
+                : NotFound();
+        }
+        var message = await db.PushMessages.AsNoTracking().FirstAsync(item => item.Id == id, ct);
+        return Ok(ToDto(message, new Dictionary<string, int>()));
+    }
+
+    [HttpGet("devices")]
+    public async Task<IActionResult> Devices(
+        [FromQuery] string? search = null,
+        [FromQuery] int limit = 50,
+        CancellationToken ct = default)
+    {
+        limit = Math.Clamp(limit, 1, 100);
+        var query = db.PushDevices.AsNoTracking().Include(device => device.User).AsQueryable();
+        if (!string.IsNullOrWhiteSpace(search))
+        {
+            var term = search.Trim();
+            query = query.Where(device => device.User.Username.Contains(term) ||
+                device.InstallationId.Contains(term));
+        }
+        var devices = await query.OrderByDescending(device => device.LastSeenAt).Take(limit).ToListAsync(ct);
+        return Ok(devices.Select(device => new
+        {
+            device.Id,
+            device.UserId,
+            device.User.Username,
+            device.Provider,
+            device.PackageName,
+            device.Flavor,
+            device.AppVersion,
+            device.VersionCode,
+            device.NotificationsAllowed,
+            device.IsActive,
+            device.DisabledReason,
+            tokenSuffix = device.TokenHash[^Math.Min(8, device.TokenHash.Length)..],
+            device.LastSeenAt,
+        }));
+    }
+
+    [HttpPost("test")]
+    public async Task<IActionResult> Test(TestPushRequest request, CancellationToken ct)
+    {
+        if (request.Title.Trim().Length is < 1 or > 80 || request.Body.Trim().Length is < 1 or > 240 ||
+            !PushCategories.All.Contains(request.Category) || !PushActions.All.Contains(request.Action))
+            return BadRequest(new ApiError("PUSH_MESSAGE_INVALID", "测试推送内容或分类无效"));
+        var device = await db.PushDevices.FirstOrDefaultAsync(item => item.Id == request.DeviceId, ct);
+        if (device is null || !device.IsActive || !device.NotificationsAllowed)
+            return BadRequest(new ApiError("PUSH_DEVICE_INACTIVE", "测试设备不存在或当前不可投递"));
+        var now = DateTime.UtcNow;
+        var message = new PushMessage
+        {
+            PublicId = Guid.NewGuid().ToString(),
+            Source = "admin",
+            State = PushMessageStates.Queued,
+            Category = request.Category.ToLowerInvariant(),
+            Title = request.Title.Trim(),
+            Body = request.Body.Trim(),
+            Action = request.Action.ToLowerInvariant(),
+            EntityId = request.EntityId?.Trim(),
+            TargetUserId = device.UserId,
+            Flavor = device.Flavor,
+            ProviderFilter = device.Provider,
+            TtlSeconds = DefaultTtl(request.Category),
+            IsTest = true,
+            TestDeviceId = device.Id,
+            CreatedAt = now,
+            UpdatedAt = now,
+        };
+        db.PushMessages.Add(message);
+        await db.SaveChangesAsync(ct);
+        return Ok(new { message.Id, message.PublicId, message.State });
+    }
+
+    [HttpGet("health")]
+    public IActionResult Health()
+    {
+        var flavors = new[] { "production", "internal" };
+        return Ok(new
+        {
+            enabled = configuration.GetValue<bool>("Push:Enabled"),
+            tokenEncryptionConfigured = !string.IsNullOrWhiteSpace(configuration["Push:TokenEncryptionKey"]),
+            providers = providers.All.Select(provider => new
+            {
+                provider = provider.Provider,
+                environments = flavors.Select(flavor => new
+                {
+                    flavor,
+                    enabled = provider.IsEnabled(flavor),
+                    errors = provider.ConfigurationErrors(flavor),
+                }),
+            }),
+        });
+    }
+
+    private IQueryable<PushDevice> EligibleDevices(CreatePushCampaignRequest request)
+    {
+        var category = request.Category.Trim().ToLowerInvariant();
+        var query = db.PushDevices.Where(device =>
+            device.IsActive && device.NotificationsAllowed &&
+            !device.User.IsBanned && device.User.AccountClosureScheduledAt == null &&
+            db.UserPushPreferences.Any(preference => preference.UserId == device.UserId &&
+                preference.Category == category && preference.IsEnabled) &&
+            device.Flavor == request.Flavor.ToLowerInvariant());
+        if (request.TargetUserId.HasValue)
+            query = query.Where(device => device.UserId == request.TargetUserId.Value);
+        if (!string.IsNullOrWhiteSpace(request.Provider))
+            query = query.Where(device => device.Provider == request.Provider.ToLowerInvariant());
+        if (request.MinVersionCode.HasValue)
+            query = query.Where(device => device.VersionCode >= request.MinVersionCode.Value);
+        if (request.MaxVersionCode.HasValue)
+            query = query.Where(device => device.VersionCode <= request.MaxVersionCode.Value);
+        return query;
+    }
+
+    private static PushMessage Map(CreatePushCampaignRequest request, PushMessage message, DateTime now)
+    {
+        message.Title = request.Title.Trim();
+        message.Body = request.Body.Trim();
+        message.Category = request.Category.Trim().ToLowerInvariant();
+        message.Action = request.Action.Trim().ToLowerInvariant();
+        message.EntityId = string.IsNullOrWhiteSpace(request.EntityId) ? null : request.EntityId.Trim();
+        message.Flavor = request.Flavor.Trim().ToLowerInvariant();
+        message.ProviderFilter = string.IsNullOrWhiteSpace(request.Provider)
+            ? null
+            : request.Provider.Trim().ToLowerInvariant();
+        message.MinVersionCode = request.MinVersionCode;
+        message.MaxVersionCode = request.MaxVersionCode;
+        message.TargetUserId = request.TargetUserId;
+        message.TtlSeconds = request.TtlSeconds ?? DefaultTtl(message.Category);
+        message.UpdatedAt = now;
+        return message;
+    }
+
+    private static ApiError? Validate(CreatePushCampaignRequest request)
+    {
+        if (request.Title.Trim().Length is < 1 or > 80)
+            return new ApiError("PUSH_TITLE_INVALID", "标题长度必须在 1 到 80 个字符之间");
+        if (request.Body.Trim().Length is < 1 or > 240)
+            return new ApiError("PUSH_BODY_INVALID", "正文长度必须在 1 到 240 个字符之间");
+        if (!PushCategories.All.Contains(request.Category))
+            return new ApiError("PUSH_CATEGORY_INVALID", "推送分类无效");
+        if (!PushActions.All.Contains(request.Action))
+            return new ApiError("PUSH_ACTION_INVALID", "点击动作无效");
+        if (request.Flavor is not ("production" or "internal"))
+            return new ApiError("PUSH_FLAVOR_INVALID", "推送环境无效");
+        if (!string.IsNullOrWhiteSpace(request.Provider) && !PushProviders.All.Contains(request.Provider))
+            return new ApiError("PUSH_PROVIDER_INVALID", "推送厂商无效");
+        if (request.MinVersionCode is < 1 || request.MaxVersionCode is < 1 ||
+            request.MinVersionCode > request.MaxVersionCode)
+            return new ApiError("PUSH_VERSION_RANGE_INVALID", "版本号范围无效");
+        if (request.TtlSeconds.HasValue && request.TtlSeconds is < 60 or > 604800)
+            return new ApiError("PUSH_TTL_INVALID", "消息有效期必须在 60 秒到 7 天之间");
+        return null;
+    }
+
+    private static int DefaultTtl(string category) => category.ToLowerInvariant() switch
+    {
+        PushCategories.System => 72 * 3600,
+        _ => 24 * 3600,
+    };
+
+    private static object ToDto(PushMessage message, IReadOnlyDictionary<string, int> counts) => new
+    {
+        message.Id,
+        message.PublicId,
+        message.State,
+        message.Title,
+        message.Body,
+        message.Category,
+        message.Action,
+        message.EntityId,
+        message.Flavor,
+        provider = message.ProviderFilter,
+        message.MinVersionCode,
+        message.MaxVersionCode,
+        message.TargetUserId,
+        message.TtlSeconds,
+        message.ScheduledAt,
+        message.CreatedAt,
+        message.StartedAt,
+        message.CompletedAt,
+        message.CancelledAt,
+        deliveries = new
+        {
+            queued = counts.GetValueOrDefault(PushDeliveryStates.Queued),
+            sending = counts.GetValueOrDefault(PushDeliveryStates.Sending),
+            accepted = counts.GetValueOrDefault(PushDeliveryStates.Accepted),
+            failed = counts.GetValueOrDefault(PushDeliveryStates.Failed),
+            skipped = counts.GetValueOrDefault(PushDeliveryStates.Skipped),
+        },
+    };
+}