327 lines
14 KiB
C#
327 lines
14 KiB
C#
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),
|
|
},
|
|
};
|
|
}
|