Add reactions, reliable push & session checks

Implements message reactions and reaction packs (domain models, services, admin HTTP API, media processing via ImageSharp and limits) and adds reliable push delivery (ChatPushNotification, ChatPushDispatcher, ChatPushWorker, improved ChatNotificationService). Enhances message reading (ReadChat API, unread counts, concurrency-safe receipts) and tightens session security (access-token session validation in JWT, hub filter, SessionAuthorization). Improves SignalR behavior (session groups, reaction/channel events, hub/error mappings). Adds EF migrations, many controller fixes (Forbid handling, password API), tests (Govor.Server.Tests), docs, CI and tooling updates (Dockerfile → .NET 10, GH Actions matrix for sqlite/postgres, Govor.Server.slnx, global.json), and small infra changes (AutoMapper bump, NullPushProvider, storage/token handling).
This commit is contained in:
Artemy
2026-10-03 17:42:24 +07:00
parent 4603be9f71
commit 29cc51ee0c
127 changed files with 7290 additions and 2488 deletions
@@ -0,0 +1,19 @@
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models.Reactions;
using SmartRes;
namespace Govor.Application.Reactions;
public record ReactionCount(Guid? ReactionId, string ReactionCode, int Count);
public record MessageReactionState(Guid MessageId, Guid RecipientId, RecipientType RecipientType,
long Version, Guid ActorId, MessageReaction? ActorReaction, IReadOnlyList<ReactionCount> Counts, bool Changed = false);
public record ChannelReactionPolicy(Guid GroupId, ChannelReactionMode Mode, long Version, IReadOnlyList<Guid> ReactionIds);
public interface IMessageReactionService
{
Task<Result<MessageReactionState, Error>> GetAsync(Guid userId, Guid messageId);
Task<Result<MessageReactionState, Error>> SetAsync(Guid userId, Guid messageId, Guid? reactionId);
Task<Result<ChannelReactionPolicy, Error>> GetPolicyAsync(Guid userId, Guid groupId);
Task<Result<ChannelReactionPolicy, Error>> SetPolicyAsync(Guid userId, Guid groupId, ChannelReactionMode mode, IReadOnlyCollection<Guid> reactionIds);
}
@@ -0,0 +1,20 @@
using Govor.Domain.Common;
using Govor.Domain.Models.Reactions;
using SmartRes;
namespace Govor.Application.Reactions;
public interface IReactionPackService
{
Task<List<ReactionPack>> ListAsync(Guid userId, bool installedOnly = false, bool includeDisabled = false, int skip = 0, int take = 50);
Task<Result<ReactionPack, Error>> GetAsync(Guid packId, bool includeDisabled = false);
Task<Result<ReactionPack, Error>> GetSharedAsync(string shareCode);
Task<Result<ReactionItem, Error>> GetReactionAsync(Guid reactionId);
Task<Result<Unit, Error>> SubscribeAsync(Guid userId, Guid packId, bool subscribe);
Task<Result<ReactionPack, Error>> CreateAsync(Guid actorId, string name, string description);
Task<Result<ReactionPack, Error>> UpdateAsync(Guid actorId, Guid packId, string name, string description, bool enabled);
Task<Result<Unit, Error>> DisableAsync(Guid actorId, Guid packId);
Task<Result<ReactionItem, Error>> AddEmojiAsync(Guid actorId, Guid packId, string name, string emoji);
Task<Result<ReactionItem, Error>> AddMediaAsync(Guid actorId, Guid packId, string name, byte[] data, CancellationToken cancellationToken = default);
Task<Result<Unit, Error>> DisableReactionAsync(Guid actorId, Guid packId, Guid reactionId);
}
@@ -0,0 +1,157 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Messages;
using Govor.Domain;
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models.Reactions;
using Microsoft.EntityFrameworkCore;
using SmartRes;
namespace Govor.Application.Reactions;
public class MessageReactionService(GovorDbContext context, INowDateTimeProvider clock) : IMessageReactionService
{
public async Task<Result<MessageReactionState, Error>> GetAsync(Guid userId, Guid messageId)
{
var message = await context.Messages.AsNoTracking().FirstOrDefaultAsync(m => m.Id == messageId);
if (message is null) return Result.Failure<MessageReactionState>(Missing());
if (!await context.HasChatAccessAsync(userId, message.RecipientId, message.RecipientType))
return Result.Failure<MessageReactionState>(Denied());
// A repeatable snapshot keeps version, counts and actor reaction consistent.
return await context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await context.Database.BeginTransactionAsync(System.Data.IsolationLevel.Serializable);
if (!await context.HasChatAccessAsync(userId, message.RecipientId, message.RecipientType))
return Result.Failure<MessageReactionState>(Denied());
var state = await StateAsync(messageId, userId);
await transaction.CommitAsync();
return state is null ? Result.Failure<MessageReactionState>(Missing()) : Result.Success(state);
});
}
public async Task<Result<MessageReactionState, Error>> SetAsync(Guid userId, Guid messageId, Guid? reactionId)
{
if (reactionId == Guid.Empty)
return Result.Failure<MessageReactionState>(Error.Validation("Reaction.InvalidId", "A reaction ID is required."));
var message = await context.Messages.AsNoTracking().FirstOrDefaultAsync(m => m.Id == messageId);
if (message is null) return Result.Failure<MessageReactionState>(Missing());
if (!await context.HasChatAccessAsync(userId, message.RecipientId, message.RecipientType))
return Result.Failure<MessageReactionState>(Denied());
return await context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await context.Database.BeginTransactionAsync();
if (message.RecipientType == RecipientType.Group)
// Same lock order as channel policy changes; serialize reaction decisions with policy writes.
await context.ChatGroups.Where(g => g.Id == message.RecipientId)
.ExecuteUpdateAsync(s => s.SetProperty(g => g.ReactionMode, g => g.ReactionMode));
if (await context.Messages.Where(m => m.Id == messageId)
.ExecuteUpdateAsync(s => s.SetProperty(m => m.ReactionsVersion, m => m.ReactionsVersion)) == 0)
return Result.Failure<MessageReactionState>(Missing());
if (!await context.HasChatAccessAsync(userId, message.RecipientId, message.RecipientType))
return Result.Failure<MessageReactionState>(Denied());
ReactionItem? item = null;
if (reactionId.HasValue)
{
item = await context.ReactionItems.AsNoTracking()
.FirstOrDefaultAsync(r => r.Id == reactionId && r.IsEnabled && r.Pack.IsEnabled);
if (item is null) return Result.Failure<MessageReactionState>(Error.NotFound("Reaction.NotAvailable", "Reaction is not available."));
var channel = message.RecipientType == RecipientType.Group
? await context.ChatGroups.AsNoTracking().FirstOrDefaultAsync(g => g.Id == message.RecipientId && g.IsChannel)
: null;
if (channel is not null && (channel.ReactionMode == ChannelReactionMode.None ||
(channel.ReactionMode == ChannelReactionMode.Selected && !await context.ChannelAllowedReactions
.AnyAsync(r => r.GroupId == channel.Id && r.ReactionId == item.Id))))
return Result.Failure<MessageReactionState>(Error.Forbidden("Reaction.ChannelRestricted", "This reaction is not allowed in the channel."));
}
var current = await context.MessageReactions.AsNoTracking().FirstOrDefaultAsync(r => r.MessageId == messageId && r.UserId == userId);
var changed = reactionId.HasValue ? current?.ReactionId != reactionId : current is not null;
if (changed)
{
if (item is null)
await context.MessageReactions.Where(r => r.MessageId == messageId && r.UserId == userId).ExecuteDeleteAsync();
else
{
var id = Guid.NewGuid();
var now = clock.Now;
await context.Database.ExecuteSqlInterpolatedAsync($"INSERT INTO \"MessageReactions\" (\"Id\", \"MessageId\", \"UserId\", \"ReactionId\", \"ReactionCode\", \"ReactedAt\") VALUES ({id}, {messageId}, {userId}, {item.Id}, {item.Code}, {now}) ON CONFLICT (\"MessageId\", \"UserId\") DO UPDATE SET \"ReactionId\" = excluded.\"ReactionId\", \"ReactionCode\" = excluded.\"ReactionCode\", \"ReactedAt\" = excluded.\"ReactedAt\"");
}
await context.Messages.Where(m => m.Id == messageId)
.ExecuteUpdateAsync(s => s.SetProperty(m => m.ReactionsVersion, m => m.ReactionsVersion + 1));
}
var state = (await StateAsync(messageId, userId))! with { Changed = changed };
await transaction.CommitAsync();
return Result.Success(state);
});
}
private async Task<MessageReactionState?> StateAsync(Guid messageId, Guid actorId)
{
var message = await context.Messages.AsNoTracking().FirstOrDefaultAsync(m => m.Id == messageId);
if (message is null) return null;
var counts = await context.MessageReactions.AsNoTracking().Where(r => r.MessageId == messageId)
.GroupBy(r => new { r.ReactionId, r.ReactionCode })
.OrderByDescending(g => g.Count()).ThenBy(g => g.Key.ReactionCode)
.Select(g => new ReactionCount(g.Key.ReactionId, g.Key.ReactionCode, g.Count()))
.ToListAsync();
var actor = await context.MessageReactions.AsNoTracking().FirstOrDefaultAsync(r => r.MessageId == messageId && r.UserId == actorId);
return new MessageReactionState(messageId, message.RecipientId, message.RecipientType,
message.ReactionsVersion, actorId, actor, counts);
}
public async Task<Result<ChannelReactionPolicy, Error>> GetPolicyAsync(Guid userId, Guid groupId)
{
if (!await context.HasChatAccessAsync(userId, groupId, RecipientType.Group))
return Result.Failure<ChannelReactionPolicy>(Denied());
return await context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await context.Database.BeginTransactionAsync(System.Data.IsolationLevel.Serializable);
var policy = await PolicyAsync(groupId);
await transaction.CommitAsync();
return Result.Success(policy);
});
}
public async Task<Result<ChannelReactionPolicy, Error>> SetPolicyAsync(Guid userId, Guid groupId,
ChannelReactionMode mode, IReadOnlyCollection<Guid> reactionIds)
{
if (!await context.HasChatAccessAsync(userId, groupId, RecipientType.Group) ||
!await context.GroupAdmins.AnyAsync(a => a.GroupId == groupId && a.UserId == userId))
return Result.Failure<ChannelReactionPolicy>(Denied());
if (!Enum.IsDefined(mode) || reactionIds is null || reactionIds.Count > 100 || reactionIds.Contains(Guid.Empty) ||
(mode != ChannelReactionMode.Selected && reactionIds.Count > 0))
return Result.Failure<ChannelReactionPolicy>(Error.Validation("Reaction.Policy.Invalid", "Provide a valid mode and at most 100 reaction IDs for Selected mode."));
var ids = reactionIds.Distinct().ToArray();
return await context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await context.Database.BeginTransactionAsync();
var updated = await context.ChatGroups.Where(g => g.Id == groupId && g.IsChannel)
.ExecuteUpdateAsync(s => s.SetProperty(g => g.ReactionMode, mode)
.SetProperty(g => g.ReactionPolicyVersion, g => g.ReactionPolicyVersion + 1));
if (updated == 0) return Result.Failure<ChannelReactionPolicy>(Error.Validation("Reaction.Policy.NotChannel", "Only channels support reaction restrictions."));
if (!await context.HasChatAccessAsync(userId, groupId, RecipientType.Group) ||
!await context.GroupAdmins.AnyAsync(a => a.GroupId == groupId && a.UserId == userId))
return Result.Failure<ChannelReactionPolicy>(Denied());
if (await context.ReactionItems.CountAsync(r => ids.Contains(r.Id) && r.IsEnabled && r.Pack.IsEnabled) != ids.Length)
return Result.Failure<ChannelReactionPolicy>(Error.Validation("Reaction.Policy.InvalidSelection", "All reactions must be active and available."));
await context.ChannelAllowedReactions.Where(r => r.GroupId == groupId).ExecuteDeleteAsync();
foreach (var id in ids)
await context.Database.ExecuteSqlInterpolatedAsync($"INSERT INTO \"ChannelAllowedReactions\" (\"GroupId\", \"ReactionId\") VALUES ({groupId}, {id})");
var policy = await PolicyAsync(groupId);
await transaction.CommitAsync();
return Result.Success(policy);
});
}
private async Task<ChannelReactionPolicy> PolicyAsync(Guid groupId)
{
var group = await context.ChatGroups.AsNoTracking().FirstAsync(g => g.Id == groupId);
var ids = await context.ChannelAllowedReactions.Where(r => r.GroupId == groupId)
.OrderBy(r => r.ReactionId).Select(r => r.ReactionId).ToListAsync();
return new ChannelReactionPolicy(groupId, group.ReactionMode, group.ReactionPolicyVersion, ids);
}
private static Error Missing() => Error.NotFound("Message.NotFound", "Message not found.");
private static Error Denied() => Error.Forbidden("Reaction.AccessDenied", "You do not have access to this chat or operation.");
}
@@ -0,0 +1,101 @@
using Govor.Domain.Common;
using Govor.Domain.Models.Reactions;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats;
using SixLabors.ImageSharp.Formats.Gif;
using SixLabors.ImageSharp.Memory;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SmartRes;
namespace Govor.Application.Reactions;
public static class ReactionMediaLimits
{
public const int MaxDimension = 128;
public const int MaxUploadBytes = 2 * 1024 * 1024;
public const int MaxImageBytes = 256 * 1024;
public const int MaxGifBytes = 512 * 1024;
public const int MaxFrames = 60;
public const int MaxDurationMilliseconds = 5000;
}
public record ProcessedReactionMedia(byte[] Data, ReactionKind Kind, string MimeType,
string Extension, int Width, int Height, int DurationMilliseconds);
public interface IReactionMediaProcessor
{
Task<Result<ProcessedReactionMedia, Error>> ProcessAsync(byte[] data, CancellationToken cancellationToken = default);
}
public class ReactionMediaProcessor : IReactionMediaProcessor
{
public async Task<Result<ProcessedReactionMedia, Error>> ProcessAsync(byte[] data, CancellationToken cancellationToken = default)
{
if (data.Length == 0 || data.Length > ReactionMediaLimits.MaxUploadBytes)
return Invalid("Upload must contain at most 2 MiB.");
try
{
var configuration = Configuration.Default.Clone();
configuration.MaxDegreeOfParallelism = 2;
configuration.MemoryAllocator = MemoryAllocator.Create(new MemoryAllocatorOptions
{ MaximumPoolSizeMegabytes = 16, AllocationLimitMegabytes = 64 });
var options = new DecoderOptions
{
Configuration = configuration, SkipMetadata = true,
MaxFrames = ReactionMediaLimits.MaxFrames + 1,
TargetSize = new Size(ReactionMediaLimits.MaxDimension, ReactionMediaLimits.MaxDimension)
};
using var input = new MemoryStream(data, writable: false);
var format = await Image.DetectFormatAsync(input, cancellationToken);
var isGif = format.Name == "GIF";
if (!isGif && format.Name is not ("PNG" or "JPEG" or "WEBP"))
return Invalid("Only PNG, JPEG, WebP and GIF are supported.");
input.Position = 0;
var info = await Image.IdentifyAsync(options, input, cancellationToken);
if (info.Width > 2048 || info.Height > 2048 || info.FrameMetadataCollection.Count > ReactionMediaLimits.MaxFrames)
return Invalid("Source dimensions must not exceed 2048 px and GIF must not exceed 60 frames.");
input.Position = 0;
using var image = await Image.LoadAsync<Rgba32>(options, input, cancellationToken);
if (image.Frames.Count > ReactionMediaLimits.MaxFrames || (!isGif && image.Frames.Count > 1))
return Invalid("Only GIF animations with at most 60 frames are supported.");
var duration = 0;
if (isGif)
{
foreach (var frame in image.Frames)
{
var metadata = frame.Metadata.GetGifMetadata();
metadata.FrameDelay = Math.Max(2, metadata.FrameDelay);
duration += metadata.FrameDelay * 10;
}
if (duration > ReactionMediaLimits.MaxDurationMilliseconds)
return Invalid("GIF duration must not exceed 5 seconds per loop.");
}
// Re-encode pixels, never store the original upload or trust its MIME/extension.
foreach (var dimension in new[] { 128, 96, 64, 48 })
{
image.Mutate(x => x.Resize(new ResizeOptions
{ Size = new Size(dimension, dimension), Mode = ResizeMode.Max }));
using var output = new MemoryStream();
if (isGif)
await image.SaveAsGifAsync(output, new GifEncoder { SkipMetadata = true }, cancellationToken);
else
await image.SaveAsPngAsync(output, cancellationToken);
if (output.Length <= (isGif ? ReactionMediaLimits.MaxGifBytes : ReactionMediaLimits.MaxImageBytes))
return new ProcessedReactionMedia(output.ToArray(), isGif ? ReactionKind.Gif : ReactionKind.Image,
isGif ? "image/gif" : "image/png", isGif ? ".gif" : ".png", image.Width, image.Height, duration);
}
return Invalid("The processed file exceeds the reaction size limit.");
}
catch (Exception ex) when (ex is UnknownImageFormatException or InvalidImageContentException or InvalidMemoryOperationException or ArgumentException)
{
return Invalid("Invalid or excessively complex image.");
}
}
private static Result<ProcessedReactionMedia, Error> Invalid(string message) =>
Result<ProcessedReactionMedia, Error>.Failure(Error.Validation("Reaction.Media.Invalid", message));
}
@@ -0,0 +1,201 @@
using System.Globalization;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Storage;
using Govor.Domain;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models.Reactions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using SmartRes;
namespace Govor.Application.Reactions;
public class ReactionPackService(GovorDbContext context, INowDateTimeProvider clock,
IReactionMediaProcessor processor, IStorageService storage, ILogger<ReactionPackService> logger) : IReactionPackService
{
public async Task<List<ReactionPack>> ListAsync(Guid userId, bool installedOnly = false,
bool includeDisabled = false, int skip = 0, int take = 50)
{
var query = context.ReactionPacks.AsNoTracking();
if (!includeDisabled) query = query.Where(p => p.IsEnabled);
if (installedOnly) query = query.Where(p => p.IsDefault || context.UserReactionPacks
.Any(s => s.UserId == userId && s.PackId == p.Id));
return await query.OrderByDescending(p => p.IsDefault).ThenBy(p => p.CreatedAt).ThenBy(p => p.Id)
.Skip(Math.Max(0, skip)).Take(Math.Clamp(take, 1, 100))
.Include(p => p.Reactions.Where(r => includeDisabled || r.IsEnabled)).AsSplitQuery().ToListAsync();
}
public async Task<Result<ReactionPack, Error>> GetAsync(Guid packId, bool includeDisabled = false)
{
var pack = await context.ReactionPacks.AsNoTracking()
.Include(p => p.Reactions.Where(r => includeDisabled || r.IsEnabled))
.FirstOrDefaultAsync(p => p.Id == packId && (includeDisabled || p.IsEnabled));
return pack is null ? Result.Failure<ReactionPack>(Missing()) : Result.Success(pack);
}
public async Task<Result<ReactionPack, Error>> GetSharedAsync(string shareCode)
{
var id = await context.ReactionPacks.Where(p => p.ShareCode == shareCode && p.IsEnabled)
.Select(p => (Guid?)p.Id).FirstOrDefaultAsync();
return id.HasValue ? await GetAsync(id.Value) : Result.Failure<ReactionPack>(Missing());
}
// Definitions remain readable after disabling so historical reactions still render.
public async Task<Result<ReactionItem, Error>> GetReactionAsync(Guid reactionId)
{
var item = await context.ReactionItems.AsNoTracking().FirstOrDefaultAsync(r => r.Id == reactionId);
return item is null ? Result.Failure<ReactionItem>(Missing()) : Result.Success(item);
}
public async Task<Result<Unit, Error>> SubscribeAsync(Guid userId, Guid packId, bool subscribe)
{
var pack = await context.ReactionPacks.AsNoTracking().FirstOrDefaultAsync(p => p.Id == packId && (!subscribe || p.IsEnabled));
if (pack is null) return Result.Failure(Missing());
if (pack.IsDefault)
return subscribe ? Result.Success() : Result.Failure(Invalid("The default pack is always available."));
if (subscribe)
await context.Database.ExecuteSqlInterpolatedAsync($"INSERT INTO \"UserReactionPacks\" (\"UserId\", \"PackId\") VALUES ({userId}, {packId}) ON CONFLICT (\"UserId\", \"PackId\") DO NOTHING");
else
await context.UserReactionPacks.Where(p => p.UserId == userId && p.PackId == packId).ExecuteDeleteAsync();
return Result.Success();
}
public async Task<Result<ReactionPack, Error>> CreateAsync(Guid actorId, string name, string description)
{
if (!await IsAdminAsync(actorId)) return Result.Failure<ReactionPack>(Denied());
if (!ValidText(name, description)) return Result.Failure<ReactionPack>(Invalid("Invalid name or description."));
var pack = new ReactionPack
{
Id = Guid.NewGuid(), Name = name.Trim(), Description = description.Trim(),
ShareCode = Guid.NewGuid().ToString("N"), CreatedByUserId = actorId, CreatedAt = clock.Now
};
context.ReactionPacks.Add(pack);
await context.SaveChangesAsync();
return pack;
}
public async Task<Result<ReactionPack, Error>> UpdateAsync(Guid actorId, Guid packId, string name, string description, bool enabled)
{
if (!await IsAdminAsync(actorId)) return Result.Failure<ReactionPack>(Denied());
if (!ValidText(name, description)) return Result.Failure<ReactionPack>(Invalid("Invalid name or description."));
var pack = await context.ReactionPacks.FirstOrDefaultAsync(p => p.Id == packId);
if (pack is null) return Result.Failure<ReactionPack>(Missing());
if (pack.IsDefault) return Result.Failure<ReactionPack>(Invalid("The default pack cannot be modified."));
pack.Name = name.Trim(); pack.Description = description.Trim(); pack.IsEnabled = enabled;
await context.SaveChangesAsync();
return pack;
}
public async Task<Result<Unit, Error>> DisableAsync(Guid actorId, Guid packId)
{
if (!await IsAdminAsync(actorId)) return Result.Failure(Denied());
var pack = await context.ReactionPacks.FirstOrDefaultAsync(p => p.Id == packId);
if (pack is null) return Result.Failure(Missing());
if (pack.IsDefault) return Result.Failure(Invalid("The default pack cannot be disabled."));
pack.IsEnabled = false;
await context.SaveChangesAsync();
return Result.Success();
}
public async Task<Result<ReactionItem, Error>> AddEmojiAsync(Guid actorId, Guid packId, string name, string emoji)
{
if (string.IsNullOrWhiteSpace(emoji) || emoji.Length > 64 || StringInfo.ParseCombiningCharacters(emoji).Length != 1 ||
!emoji.EnumerateRunes().Any(r => System.Text.Rune.GetUnicodeCategory(r) == UnicodeCategory.OtherSymbol))
return Result.Failure<ReactionItem>(Invalid("Provide a single emoji grapheme."));
return await AddAsync(actorId, packId, name, emoji, null);
}
public async Task<Result<ReactionItem, Error>> AddMediaAsync(Guid actorId, Guid packId, string name, byte[] data,
CancellationToken cancellationToken = default)
{
if (!await IsAdminAsync(actorId)) return Result.Failure<ReactionItem>(Denied());
if (!await context.ReactionPacks.AnyAsync(p => p.Id == packId && !p.IsDefault && p.IsEnabled))
return Result.Failure<ReactionItem>(Invalid("An active custom pack is required."));
var processed = await processor.ProcessAsync(data, cancellationToken);
if (processed.IsFailure) return Result.Failure<ReactionItem>(processed.Error);
return await AddAsync(actorId, packId, name, null, processed.Value);
}
private async Task<Result<ReactionItem, Error>> AddAsync(Guid actorId, Guid packId, string name,
string? emoji, ProcessedReactionMedia? media)
{
if (!await IsAdminAsync(actorId)) return Result.Failure<ReactionItem>(Denied());
if (!ValidText(name, "")) return Result.Failure<ReactionItem>(Invalid("Invalid reaction name."));
var operationId = Guid.NewGuid();
return await context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
var completed = await context.ReactionItems.AsNoTracking().FirstOrDefaultAsync(r => r.Id == operationId);
if (completed is not null) return Result.Success(completed);
await using var transaction = await context.Database.BeginTransactionAsync();
// Lock the pack to serialize the item limit and concurrent disabling.
var locked = await context.ReactionPacks.Where(p => p.Id == packId && !p.IsDefault && p.IsEnabled)
.ExecuteUpdateAsync(s => s.SetProperty(p => p.Name, p => p.Name));
if (locked == 0) return Result.Failure<ReactionItem>(Invalid("An active custom pack is required."));
if (await context.ReactionItems.CountAsync(r => r.PackId == packId) >= 100)
return Result.Failure<ReactionItem>(Invalid("A pack can contain at most 100 reactions, including disabled entries."));
var item = new ReactionItem
{
Id = operationId, PackId = packId, Name = name.Trim(), Emoji = emoji,
Kind = media?.Kind ?? ReactionKind.Emoji, CreatedAt = clock.Now
};
item.Code = $":reaction_{item.Id:N}:";
string? path = null;
try
{
if (media is not null)
{
path = await storage.SaveAsync(media.Data, item.Id.ToString("N") + media.Extension);
var file = new MediaFile
{
Id = Guid.NewGuid(), UploaderId = actorId, Url = path, MineType = media.MimeType,
DateCreated = clock.Now, OwnerType = MediaOwnerType.Reaction, OwnerId = item.Id,
MediaType = MediaType.Image
};
context.MediaFiles.Add(file);
item.MediaFileId = file.Id; item.Width = media.Width; item.Height = media.Height;
item.SizeBytes = media.Data.Length; item.DurationMilliseconds = media.DurationMilliseconds;
}
context.ReactionItems.Add(item);
await context.SaveChangesAsync();
}
catch
{
if (path is not null)
{
try { await storage.RemoveAsync(path); }
catch (Exception ex) { logger.LogError(ex, "Cannot remove failed reaction upload {ReactionId}", item.Id); }
}
// Clear failed tracked additions before an execution-strategy retry.
context.ChangeTracker.Clear();
throw;
}
// Do not delete the file on an ambiguous Commit outcome. The stable operation ID
// above detects an already committed item when the execution strategy retries.
try { await transaction.CommitAsync(); }
catch { context.ChangeTracker.Clear(); throw; }
return Result.Success(item);
});
}
public async Task<Result<Unit, Error>> DisableReactionAsync(Guid actorId, Guid packId, Guid reactionId)
{
if (!await IsAdminAsync(actorId)) return Result.Failure(Denied());
var item = await context.ReactionItems.Include(r => r.Pack)
.FirstOrDefaultAsync(r => r.Id == reactionId && r.PackId == packId);
if (item is null) return Result.Failure(Missing());
if (item.Pack.IsDefault) return Result.Failure(Invalid("Default reactions cannot be disabled."));
item.IsEnabled = false;
await context.SaveChangesAsync();
return Result.Success();
}
private Task<bool> IsAdminAsync(Guid actorId) => context.Users.AnyAsync(u => u.Id == actorId && u.Invite != null && u.Invite.IsAdmin);
private static bool ValidText(string name, string description) => !string.IsNullOrWhiteSpace(name) &&
name.Trim().Length <= 100 && description is not null && description.Length <= 500;
private static Error Invalid(string message) => Error.Validation("ReactionPack.Invalid", message);
private static Error Missing() => Error.NotFound("ReactionPack.NotFound", "Reaction pack or item not found.");
private static Error Denied() => Error.Forbidden("ReactionPack.AdminRequired", "Administrator permission is required.");
}