Add primitive groups and required channel

Adds server-side group and channel management, private invitations, member moderation, avatar handling, and required-channel configuration. This change also introduces SignalR group profile/member notifications, updates registration to atomically join required channels, and adds EF migration and test coverage for group membership, permissions, and invitation expiry rules.
This commit is contained in:
Artemy
2026-10-04 10:35:07 +07:00
parent fed8f518ee
commit 2e9d7e625e
48 changed files with 3593 additions and 167 deletions
+60 -23
View File
@@ -1,5 +1,6 @@
using Govor.Application.Authentication.Exceptions;
using Govor.Application.Infrastructure.Validators;
using Govor.Application.Infrastructure.Common;
using Govor.Application.Users;
using Govor.Domain;
using Govor.Domain.Common;
@@ -16,17 +17,20 @@ public class AuthService : IAccountService
private readonly IPasswordHasher _passwordHasher;
private readonly IUserNameExistValidator _userNameExistValidator;
private readonly IUsernameValidator _usernameValidator;
private readonly INowDateTimeProvider _clock;
public AuthService(
GovorDbContext context,
IUserNameExistValidator existValidator,
IPasswordHasher passwordHasher,
IUsernameValidator usernameValidator)
IUsernameValidator usernameValidator,
INowDateTimeProvider clock)
{
_context = context;
_userNameExistValidator = existValidator;
_passwordHasher = passwordHasher;
_usernameValidator = usernameValidator;
_clock = clock;
}
public async Task<Result<User, Error>> RegistrationAsync(string name, string password, Invitation invitation)
@@ -46,30 +50,63 @@ public class AuthService : IAccountService
var passwordHash = _passwordHasher.Hash(password);
var user = new User
var operationId = Guid.NewGuid();
return await _context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
Id = Guid.NewGuid(),
Username = name,
PasswordHash = passwordHash,
Description = string.Empty,
CreatedOn = DateOnly.FromDateTime(DateTime.UtcNow),
IconId = Guid.Empty,
WasOnline = DateTime.UtcNow,
InviteId = invitation.Id
};
await _context.Users.AddAsync(user);
await SetRoleAsync(user, invitation);
invitation.Participants += 1;
await _context.SaveChangesAsync();
return user; // Success
var completed = await _context.Users.AsNoTracking().FirstOrDefaultAsync(u => u.Id == operationId);
if (completed is not null) return Result.Success(completed);
await using var transaction = await _context.Database.BeginTransactionAsync();
try
{
// Serialize configuration changes with registration: account and membership commit together.
await _context.ServerCommunitySettings.Where(s => s.Id == 1)
.ExecuteUpdateAsync(s => s.SetProperty(s => s.AllowLeave, s => s.AllowLeave));
var settings = await _context.ServerCommunitySettings.AsNoTracking().SingleAsync(s => s.Id == 1);
if (settings.RequiredChannelId.HasValue &&
!await _context.ChatGroups.AnyAsync(g => g.Id == settings.RequiredChannelId && g.IsChannel))
return Result.Failure<User>(Error.Validation("Auth.RequiredChannelUnavailable", "The required channel is unavailable."));
var now = _clock.Now;
var reserved = await _context.Invitations.Where(i => i.Id == invitation.Id &&
i.IsActive && i.EndDate > now && i.Participants < i.MaxParticipants &&
_context.Users.Count(u => u.InviteId == i.Id) < i.MaxParticipants)
.ExecuteUpdateAsync(s => s.SetProperty(i => i.Participants, i => i.Participants + 1));
if (reserved == 0)
return Result.Failure<User>(Error.Validation("Auth.InvitationUnavailable", "Registration invitation is expired or full."));
var user = new User
{
Id = operationId, Username = name, PasswordHash = passwordHash, Description = string.Empty,
CreatedOn = DateOnly.FromDateTime(now), IconId = Guid.Empty, WasOnline = now, InviteId = invitation.Id
};
await _context.Users.AddAsync(user);
await SetRoleAsync(user, invitation);
if (settings.RequiredChannelId.HasValue)
{
_context.GroupMemberships.Add(new GroupMembership
{
Id = Guid.NewGuid(), GroupId = settings.RequiredChannelId.Value, UserId = user.Id, MemberSince = now
});
}
await _context.SaveChangesAsync();
await transaction.CommitAsync();
return Result.Success(user);
}
catch
{
_context.ChangeTracker.Clear();
throw;
}
});
}
public async Task<Result<User, Error>> LoginAsync(string name, string password)
{
var user = await _context.Users
@@ -1,4 +1,5 @@
using Govor.Domain;
using Govor.Application.Infrastructure.Common;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Govor.Domain.Models.Users;
@@ -10,10 +11,12 @@ namespace Govor.Application.Authentication;
public class InvitesService : IInvitesService
{
private readonly GovorDbContext _context;
private readonly INowDateTimeProvider _clock;
public InvitesService(GovorDbContext context)
public InvitesService(GovorDbContext context, INowDateTimeProvider clock)
{
_context = context;
_clock = clock;
}
public async Task<string> GetRoleNameAsync(User user)
@@ -40,7 +43,7 @@ public class InvitesService : IInvitesService
if (invite == null)
return Result.Failure<Invitation>(Error.NotFound("Auth.LinkNotFount","Invitation not found."));
if (invite.EndDate < DateTime.Now || invite.MaxParticipants <= invite.Users.Count || invite.MaxParticipants <= invite.Participants)
if (!invite.IsActive || invite.EndDate <= _clock.Now || invite.MaxParticipants <= invite.Users.Count || invite.MaxParticipants <= invite.Participants)
{
invite.IsActive = false;
await _context.SaveChangesAsync();
+12
View File
@@ -0,0 +1,12 @@
using Govor.Domain;
using Microsoft.EntityFrameworkCore;
namespace Govor.Application.Groups;
public static class GroupAccess
{
public static Task<bool> IsGroupAdministratorAsync(this GovorDbContext context, Guid groupId, Guid userId) =>
context.ChatGroups.AnyAsync(g => g.Id == groupId &&
context.GroupMemberships.Any(m => m.GroupId == groupId && m.UserId == userId && !m.IsBanned) &&
(g.OwnerUserId == userId || context.GroupAdmins.Any(a => a.GroupId == groupId && a.UserId == userId)));
}
@@ -0,0 +1,82 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Reactions;
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.Groups;
public interface IGroupAvatarService
{
Task<Result<Guid, Error>> UploadAsync(Guid actorId, Guid groupId, byte[] data, CancellationToken cancellationToken = default);
Task<Result<Unit, Error>> RemoveAsync(Guid actorId, Guid groupId);
}
public class GroupAvatarService (GovorDbContext context,
INowDateTimeProvider clock,
IReactionMediaProcessor processor,
IStorageService storage,
ILogger<GroupAvatarService> logger) : IGroupAvatarService
{
public async Task<Result<Guid, Error>> UploadAsync(Guid actorId, Guid groupId, byte[] data, CancellationToken cancellationToken = default)
{
if (!await IsOwnerAsync(actorId, groupId)) return Result.Failure<Guid>(Denied());
var processed = await processor.ProcessAsync(data, cancellationToken);
if (processed.IsFailure) return Result.Failure<Guid>(processed.Error);
if (processed.Value.Kind == ReactionKind.Gif)
return Result.Failure<Guid>(Error.Validation("Group.Avatar.Invalid", "A static PNG, JPEG or WebP image is required."));
var operationId = Guid.NewGuid();
return await context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
var completed = await context.MediaFiles.AsNoTracking().FirstOrDefaultAsync(f => f.Id == operationId);
if (completed is not null) return Result.Success(completed.Id);
await using var transaction = await context.Database.BeginTransactionAsync();
await context.ChatGroups.Where(g => g.Id == groupId).ExecuteUpdateAsync(s => s.SetProperty(g => g.Name, g => g.Name));
if (!await IsOwnerAsync(actorId, groupId)) return Result.Failure<Guid>(Denied());
string? path = null;
try
{
path = await storage.SaveAsync(processed.Value.Data, operationId.ToString("N") + ".png");
context.MediaFiles.Add(new MediaFile
{
Id = operationId, UploaderId = actorId, OwnerType = MediaOwnerType.GroupAvatar, OwnerId = groupId,
DateCreated = clock.Now, MineType = "image/png", MediaType = MediaType.Image, Url = path
});
await context.SaveChangesAsync();
await context.ChatGroups.Where(g => g.Id == groupId).ExecuteUpdateAsync(s => s.SetProperty(g => g.ImageId, operationId));
}
catch
{
context.ChangeTracker.Clear();
if (path is not null)
try { await storage.RemoveAsync(path); }
catch (Exception ex) { logger.LogError(ex, "Cannot remove failed group avatar {MediaId}", operationId); }
throw;
}
// Preserve the file if commit has an ambiguous outcome; retry checks operationId.
try { await transaction.CommitAsync(); }
catch { context.ChangeTracker.Clear(); throw; }
return Result.Success(operationId);
});
}
public Task<Result<Unit, Error>> RemoveAsync(Guid actorId, Guid groupId) => context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await context.Database.BeginTransactionAsync();
await context.ChatGroups.Where(g => g.Id == groupId).ExecuteUpdateAsync(s => s.SetProperty(g => g.Name, g => g.Name));
if (!await IsOwnerAsync(actorId, groupId)) return Result.Failure(Denied());
await context.ChatGroups.Where(g => g.Id == groupId).ExecuteUpdateAsync(s => s.SetProperty(g => g.ImageId, Guid.Empty));
await transaction.CommitAsync();
return Result.Success();
});
private Task<bool> IsOwnerAsync(Guid actorId, Guid groupId) => context.ChatGroups.AnyAsync(g => g.Id == groupId && g.OwnerUserId == actorId &&
context.GroupMemberships.Any(m => m.GroupId == groupId && m.UserId == actorId && !m.IsBanned));
private static Error Denied() => Error.Forbidden("Group.Avatar.OwnerRequired", "Only the active group owner can change its avatar.");
}
@@ -0,0 +1,281 @@
using Govor.Application.Infrastructure.Common;
using Govor.Domain;
using Govor.Domain.Common;
using Govor.Domain.Models;
using Microsoft.EntityFrameworkCore;
using SmartRes;
namespace Govor.Application.Groups;
public class GroupManagementService(GovorDbContext context, INowDateTimeProvider clock) : IGroupManagementService
{
public async Task<Result<GroupSummary, Error>> CreateAsync(Guid actorId, string name, string description, bool isPrivate, bool isChannel)
{
if (!ValidText(name, description)) return Result.Failure<GroupSummary>(Invalid("Invalid group profile."));
if (!await context.Users.AnyAsync(u => u.Id == actorId)) return Result.Failure<GroupSummary>(Denied());
var group = new ChatGroup
{
Id = Guid.NewGuid(), Name = name.Trim(), Description = description.Trim(), IsPrivate = isPrivate,
IsChannel = isChannel, OwnerUserId = actorId, CreatedAt = clock.Now
};
group.Members.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = actorId, MemberSince = clock.Now });
context.ChatGroups.Add(group);
await context.SaveChangesAsync();
return await SummaryAsync(group, actorId);
}
public async Task<Result<GroupSummary, Error>> GetAsync(Guid actorId, Guid groupId)
{
var group = await context.ChatGroups.AsNoTracking().FirstOrDefaultAsync(g => g.Id == groupId);
if (group is null || await IsBannedAsync(groupId, actorId) ||
(group.IsPrivate && !await IsMemberAsync(groupId, actorId))) return Result.Failure<GroupSummary>(Missing());
return await SummaryAsync(group, actorId);
}
public async Task<List<GroupSummary>> SearchAsync(Guid actorId, string query, int skip = 0, int take = 50)
{
query = (query ?? "").Trim().ToLowerInvariant();
var groups = await context.ChatGroups.AsNoTracking().Where(g => !g.IsPrivate &&
!context.GroupMemberships.Any(m => m.GroupId == g.Id && m.UserId == actorId && m.IsBanned) &&
(query == "" || g.Name.ToLower().Contains(query) || g.Description.ToLower().Contains(query)))
.OrderBy(g => g.Name).ThenBy(g => g.Id).Skip(Math.Max(0, skip)).Take(Math.Clamp(take, 1, 100)).ToListAsync();
var result = new List<GroupSummary>();
foreach (var group in groups) result.Add(await SummaryAsync(group, actorId));
return result;
}
public async Task<List<GroupSummary>> MineAsync(Guid actorId, int skip = 0, int take = 50)
{
var groups = await context.ChatGroups.AsNoTracking().Where(g => context.GroupMemberships
.Any(m => m.GroupId == g.Id && m.UserId == actorId && !m.IsBanned))
.OrderBy(g => g.Name).ThenBy(g => g.Id).Skip(Math.Max(0, skip)).Take(Math.Clamp(take, 1, 100)).ToListAsync();
var result = new List<GroupSummary>();
foreach (var group in groups) result.Add(await SummaryAsync(group, actorId));
return result;
}
public async Task<Result<GroupSummary, Error>> UpdateAsync(Guid actorId, Guid groupId, string name, string description, bool isPrivate)
{
if (!ValidText(name, description)) return Result.Failure<GroupSummary>(Invalid("Invalid group profile."));
var changed = await MutateAsync(groupId, async group =>
{
if (!await IsOwnerAsync(group, actorId)) return Result.Failure(Denied());
await context.ChatGroups.Where(g => g.Id == groupId).ExecuteUpdateAsync(s =>
s.SetProperty(g => g.Name, name.Trim()).SetProperty(g => g.Description, description.Trim())
.SetProperty(g => g.IsPrivate, isPrivate));
return Result.Success();
});
return changed.IsFailure ? Result.Failure<GroupSummary>(changed.Error) : await GetAsync(actorId, groupId);
}
public Task<Result<GroupSummary, Error>> JoinPublicAsync(Guid actorId, Guid groupId) => JoinAsync(actorId, groupId, null);
public async Task<Result<GroupSummary, Error>> JoinByInvitationAsync(Guid actorId, string code)
{
var groupId = await context.GroupInvitations.Where(i => i.InvitationCode == code)
.Select(i => (Guid?)i.GroupId).FirstOrDefaultAsync();
return groupId.HasValue ? await JoinAsync(actorId, groupId.Value, code) : Result.Failure<GroupSummary>(Missing());
}
public async Task<Result<GroupSummary, Error>> PreviewInvitationAsync(Guid actorId, string code)
{
var invitation = await context.GroupInvitations.AsNoTracking().FirstOrDefaultAsync(i => i.InvitationCode == code);
if (invitation is null || !Usable(invitation) || await IsBannedAsync(invitation.GroupId, actorId))
return Result.Failure<GroupSummary>(Missing());
var group = await context.ChatGroups.AsNoTracking().FirstOrDefaultAsync(g => g.Id == invitation.GroupId);
return group is null ? Result.Failure<GroupSummary>(Missing()) : Result.Success(await SummaryAsync(group, actorId));
}
private async Task<Result<GroupSummary, Error>> JoinAsync(Guid actorId, Guid groupId, string? code)
{
var joined = await MutateAsync(groupId, async group =>
{
if (!await context.Users.AnyAsync(u => u.Id == actorId)) return Result.Failure(Denied());
var membership = await context.GroupMemberships.AsNoTracking()
.FirstOrDefaultAsync(m => m.GroupId == groupId && m.UserId == actorId);
if (membership?.IsBanned == true) return Result.Failure(Denied());
GroupInvitation? invitation = null;
if (code is not null)
{
invitation = await context.GroupInvitations.AsNoTracking()
.FirstOrDefaultAsync(i => i.GroupId == groupId && i.InvitationCode == code);
if (invitation is null || invitation.IsRevoked || invitation.EndDate <= clock.Now) return Result.Failure(Missing());
}
else if (group.IsPrivate) return Result.Failure(Denied());
if (membership is not null) return Result.Success();
if (invitation is not null && !Usable(invitation)) return Result.Failure(Invalid("Invitation has reached its usage limit."));
var id = Guid.NewGuid();
Guid? invitationId = invitation?.Id;
var now = clock.Now;
await context.Database.ExecuteSqlInterpolatedAsync($"INSERT INTO \"GroupMemberships\" (\"Id\", \"GroupId\", \"UserId\", \"InvitationId\", \"IsBanned\", \"MemberSince\") VALUES ({id}, {groupId}, {actorId}, {invitationId}, {false}, {now})");
if (invitation is not null)
await context.GroupInvitations.Where(i => i.Id == invitation.Id)
.ExecuteUpdateAsync(s => s.SetProperty(i => i.UsedCount, i => i.UsedCount + 1));
return Result.Success();
});
return joined.IsFailure ? Result.Failure<GroupSummary>(joined.Error) : await GetAsync(actorId, groupId);
}
public Task<Result<Unit, Error>> LeaveAsync(Guid actorId, Guid groupId) => MutateAsync(groupId, async group =>
{
if (!await IsMemberAsync(groupId, actorId)) return Result.Failure(Denied());
if (group.OwnerUserId == actorId) return Result.Failure(Invalid("Transfer ownership before leaving."));
if (await context.ServerCommunitySettings.AnyAsync(s => s.Id == 1 && s.RequiredChannelId == groupId && !s.AllowLeave))
return Result.Failure(Denied("Leaving the required channel is disabled."));
await context.GroupAdmins.Where(a => a.GroupId == groupId && a.UserId == actorId).ExecuteDeleteAsync();
await context.GroupMemberships.Where(m => m.GroupId == groupId && m.UserId == actorId).ExecuteDeleteAsync();
return Result.Success();
});
public async Task<Result<List<GroupMember>, Error>> MembersAsync(Guid actorId, Guid groupId, bool bannedOnly, int skip, int take)
{
if (!await IsMemberAsync(groupId, actorId) || (bannedOnly && !await context.IsGroupAdministratorAsync(groupId, actorId)))
return Result.Failure<List<GroupMember>>(Denied());
var group = await context.ChatGroups.AsNoTracking().FirstAsync(g => g.Id == groupId);
var members = await (from m in context.GroupMemberships.AsNoTracking()
join u in context.Users on m.UserId equals u.Id
where m.GroupId == groupId && m.IsBanned == bannedOnly
orderby m.MemberSince, m.UserId
select new { m.UserId, u.Username, m.MemberSince, m.IsBanned,
Admin = context.GroupAdmins.Any(a => a.GroupId == groupId && a.UserId == m.UserId) })
.Skip(Math.Max(0, skip)).Take(Math.Clamp(take, 1, 100)).ToListAsync();
return members.Select(m => new GroupMember(m.UserId, m.Username,
group.OwnerUserId == m.UserId ? GroupRole.Owner : m.Admin ? GroupRole.Admin : GroupRole.Member,
m.IsBanned, m.MemberSince)).ToList();
}
public Task<Result<Unit, Error>> SetAdministratorAsync(Guid actorId, Guid groupId, Guid targetId, bool isAdmin) =>
MutateAsync(groupId, async group =>
{
if (!await IsOwnerAsync(group, actorId)) return Result.Failure(Denied());
if (group.OwnerUserId == targetId || !await IsMemberAsync(groupId, targetId))
return Result.Failure(Invalid("Choose an active member other than the owner."));
if (isAdmin)
{
var id = Guid.NewGuid();
await context.Database.ExecuteSqlInterpolatedAsync($"INSERT INTO \"GroupAdmins\" (\"Id\", \"GroupId\", \"UserId\") VALUES ({id}, {groupId}, {targetId}) ON CONFLICT (\"GroupId\", \"UserId\") DO NOTHING");
}
else await context.GroupAdmins.Where(a => a.GroupId == groupId && a.UserId == targetId).ExecuteDeleteAsync();
return Result.Success();
});
public Task<Result<Unit, Error>> SetBanAsync(Guid actorId, Guid groupId, Guid targetId, bool banned) => MutateAsync(groupId, async group =>
{
if (!await context.IsGroupAdministratorAsync(groupId, actorId)) return Result.Failure(Denied());
if (targetId == actorId || group.OwnerUserId == targetId ||
(group.OwnerUserId != actorId && await context.GroupAdmins.AnyAsync(a => a.GroupId == groupId && a.UserId == targetId)))
return Result.Failure(Denied("Administrators cannot moderate the owner or another administrator."));
if (!await context.GroupMemberships.AnyAsync(m => m.GroupId == groupId && m.UserId == targetId))
return Result.Failure(Missing());
await context.GroupMemberships.Where(m => m.GroupId == groupId && m.UserId == targetId)
.ExecuteUpdateAsync(s => s.SetProperty(m => m.IsBanned, banned));
if (banned) await context.GroupAdmins.Where(a => a.GroupId == groupId && a.UserId == targetId).ExecuteDeleteAsync();
return Result.Success();
});
public Task<Result<Unit, Error>> TransferOwnershipAsync(Guid actorId, Guid groupId, Guid targetId) => MutateAsync(groupId, async group =>
{
if (!await IsOwnerAsync(group, actorId)) return Result.Failure(Denied());
if (targetId == actorId || !await IsMemberAsync(groupId, targetId)) return Result.Failure(Invalid("Choose another active member."));
await context.ChatGroups.Where(g => g.Id == groupId).ExecuteUpdateAsync(s => s.SetProperty(g => g.OwnerUserId, targetId));
var id = Guid.NewGuid();
await context.Database.ExecuteSqlInterpolatedAsync($"INSERT INTO \"GroupAdmins\" (\"Id\", \"GroupId\", \"UserId\") VALUES ({id}, {groupId}, {actorId}) ON CONFLICT (\"GroupId\", \"UserId\") DO NOTHING");
await context.GroupAdmins.Where(a => a.GroupId == groupId && a.UserId == targetId).ExecuteDeleteAsync();
return Result.Success();
});
public async Task<Result<GroupInvitation, Error>> CreateInvitationAsync(Guid actorId, Guid groupId, int days, int maxParticipants, string description)
{
if (days is < 1 or > 365 || maxParticipants is < 0 or > 1000000 || description is null || description.Length > 500)
return Result.Failure<GroupInvitation>(Invalid("Invalid invitation limits."));
var invitation = new GroupInvitation
{
Id = Guid.NewGuid(), GroupId = groupId, UserMakerId = actorId, InvitationCode = Guid.NewGuid().ToString("N"),
Description = description.Trim(), CreatedAt = clock.Now, EndDate = clock.Now.AddDays(days), MaxParticipants = maxParticipants
};
var result = await MutateAsync(groupId, async group =>
{
if (!await context.IsGroupAdministratorAsync(groupId, actorId)) return Result.Failure(Denied());
// A stable ID makes an execution-strategy retry safe after an ambiguous commit.
if (!await context.GroupInvitations.AnyAsync(i => i.Id == invitation.Id))
await context.Database.ExecuteSqlInterpolatedAsync($"INSERT INTO \"GroupInvitations\" (\"Id\", \"GroupId\", \"UserMakerId\", \"InvitationCode\", \"Description\", \"CreatedAt\", \"EndDate\", \"MaxParticipants\", \"UsedCount\", \"IsRevoked\") VALUES ({invitation.Id}, {groupId}, {actorId}, {invitation.InvitationCode}, {invitation.Description}, {invitation.CreatedAt}, {invitation.EndDate}, {maxParticipants}, {0}, {false})");
return Result.Success();
});
return result.IsFailure ? Result.Failure<GroupInvitation>(result.Error) : Result.Success(invitation);
}
public async Task<Result<List<GroupInvitation>, Error>> InvitationsAsync(Guid actorId, Guid groupId)
{
if (!await context.IsGroupAdministratorAsync(groupId, actorId)) return Result.Failure<List<GroupInvitation>>(Denied());
return await context.GroupInvitations.AsNoTracking().Where(i => i.GroupId == groupId)
.OrderByDescending(i => i.CreatedAt).ThenBy(i => i.Id).Take(100).ToListAsync();
}
public Task<Result<Unit, Error>> RevokeInvitationAsync(Guid actorId, Guid groupId, Guid invitationId) => MutateAsync(groupId, async group =>
{
if (!await context.IsGroupAdministratorAsync(groupId, actorId)) return Result.Failure(Denied());
var count = await context.GroupInvitations.Where(i => i.Id == invitationId && i.GroupId == groupId)
.ExecuteUpdateAsync(s => s.SetProperty(i => i.IsRevoked, true));
return count == 0 ? Result.Failure(Missing()) : Result.Success();
});
public async Task<Result<ServerCommunitySettings, Error>> GetRequiredChannelAsync(Guid actorId)
{
if (!await IsServerAdminAsync(actorId)) return Result.Failure<ServerCommunitySettings>(Denied());
return await context.ServerCommunitySettings.AsNoTracking().SingleAsync(s => s.Id == 1);
}
public async Task<Result<ServerCommunitySettings, Error>> SetRequiredChannelAsync(Guid actorId, Guid? channelId, bool allowLeave)
{
if (channelId == Guid.Empty) return Result.Failure<ServerCommunitySettings>(Invalid("Use a valid channel ID or null."));
return await context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await context.Database.BeginTransactionAsync();
await context.ServerCommunitySettings.Where(s => s.Id == 1)
.ExecuteUpdateAsync(s => s.SetProperty(s => s.AllowLeave, s => s.AllowLeave));
if (!await IsServerAdminAsync(actorId)) return Result.Failure<ServerCommunitySettings>(Denied());
if (channelId.HasValue && !await context.ChatGroups.AnyAsync(g => g.Id == channelId && g.IsChannel && g.OwnerUserId != null))
return Result.Failure<ServerCommunitySettings>(Invalid("Choose an existing channel with an owner."));
await context.ServerCommunitySettings.Where(s => s.Id == 1).ExecuteUpdateAsync(s =>
s.SetProperty(s => s.RequiredChannelId, channelId).SetProperty(s => s.AllowLeave, allowLeave));
var settings = await context.ServerCommunitySettings.AsNoTracking().SingleAsync(s => s.Id == 1);
await transaction.CommitAsync();
return Result.Success(settings);
});
}
// Every membership/role/invitation decision is serialized on its group row.
private Task<Result<Unit, Error>> MutateAsync(Guid groupId, Func<ChatGroup, Task<Result<Unit, Error>>> mutation) =>
context.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await context.Database.BeginTransactionAsync();
var count = await context.ChatGroups.Where(g => g.Id == groupId).ExecuteUpdateAsync(s => s.SetProperty(g => g.Name, g => g.Name));
if (count == 0) return Result.Failure(Missing());
var group = await context.ChatGroups.AsNoTracking().SingleAsync(g => g.Id == groupId);
var result = await mutation(group);
if (result.IsSuccess) await transaction.CommitAsync();
return result;
});
private async Task<GroupSummary> SummaryAsync(ChatGroup group, Guid actorId)
{
var member = await IsMemberAsync(group.Id, actorId);
GroupRole? role = member ? group.OwnerUserId == actorId ? GroupRole.Owner :
await context.GroupAdmins.AnyAsync(a => a.GroupId == group.Id && a.UserId == actorId) ? GroupRole.Admin : GroupRole.Member : null;
var settings = await context.ServerCommunitySettings.AsNoTracking().SingleAsync(s => s.Id == 1);
var required = settings.RequiredChannelId == group.Id;
return new GroupSummary(group, await context.GroupMemberships.CountAsync(m => m.GroupId == group.Id && !m.IsBanned),
role, required, member && group.OwnerUserId != actorId && (!required || settings.AllowLeave));
}
private Task<bool> IsMemberAsync(Guid groupId, Guid userId) => context.GroupMemberships.AnyAsync(m => m.GroupId == groupId && m.UserId == userId && !m.IsBanned);
private Task<bool> IsBannedAsync(Guid groupId, Guid userId) => context.GroupMemberships.AnyAsync(m => m.GroupId == groupId && m.UserId == userId && m.IsBanned);
private async Task<bool> IsOwnerAsync(ChatGroup group, Guid userId) => group.OwnerUserId == userId && await IsMemberAsync(group.Id, userId);
private Task<bool> IsServerAdminAsync(Guid userId) => context.Users.AnyAsync(u => u.Id == userId && u.Invite != null && u.Invite.IsAdmin);
private bool Usable(GroupInvitation invitation) => !invitation.IsRevoked && invitation.EndDate > clock.Now &&
(invitation.MaxParticipants == 0 || invitation.UsedCount < invitation.MaxParticipants);
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("Group.Invalid", message);
private static Error Missing() => Error.NotFound("Group.NotFound", "Group or invitation not found.");
private static Error Denied(string message = "You do not have permission for this group operation.") => Error.Forbidden("Group.AccessDenied", message);
}
@@ -0,0 +1,30 @@
using Govor.Domain.Common;
using Govor.Domain.Models;
using SmartRes;
namespace Govor.Application.Groups;
public record GroupSummary(ChatGroup Group, int MemberCount, GroupRole? MyRole, bool IsRequiredChannel, bool CanLeave);
public record GroupMember(Guid UserId, string Username, GroupRole Role, bool IsBanned, DateTime MemberSince);
public interface IGroupManagementService
{
Task<Result<GroupSummary, Error>> CreateAsync(Guid actorId, string name, string description, bool isPrivate, bool isChannel);
Task<Result<GroupSummary, Error>> GetAsync(Guid actorId, Guid groupId);
Task<List<GroupSummary>> SearchAsync(Guid actorId, string query, int skip = 0, int take = 50);
Task<List<GroupSummary>> MineAsync(Guid actorId, int skip = 0, int take = 50);
Task<Result<GroupSummary, Error>> UpdateAsync(Guid actorId, Guid groupId, string name, string description, bool isPrivate);
Task<Result<GroupSummary, Error>> JoinPublicAsync(Guid actorId, Guid groupId);
Task<Result<GroupSummary, Error>> JoinByInvitationAsync(Guid actorId, string code);
Task<Result<GroupSummary, Error>> PreviewInvitationAsync(Guid actorId, string code);
Task<Result<Unit, Error>> LeaveAsync(Guid actorId, Guid groupId);
Task<Result<List<GroupMember>, Error>> MembersAsync(Guid actorId, Guid groupId, bool bannedOnly, int skip, int take);
Task<Result<Unit, Error>> SetAdministratorAsync(Guid actorId, Guid groupId, Guid targetId, bool isAdmin);
Task<Result<Unit, Error>> SetBanAsync(Guid actorId, Guid groupId, Guid targetId, bool banned);
Task<Result<Unit, Error>> TransferOwnershipAsync(Guid actorId, Guid groupId, Guid targetId);
Task<Result<GroupInvitation, Error>> CreateInvitationAsync(Guid actorId, Guid groupId, int days, int maxParticipants, string description);
Task<Result<List<GroupInvitation>, Error>> InvitationsAsync(Guid actorId, Guid groupId);
Task<Result<Unit, Error>> RevokeInvitationAsync(Guid actorId, Guid groupId, Guid invitationId);
Task<Result<ServerCommunitySettings, Error>> GetRequiredChannelAsync(Guid actorId);
Task<Result<ServerCommunitySettings, Error>> SetRequiredChannelAsync(Guid actorId, Guid? channelId, bool allowLeave);
}
@@ -17,9 +17,9 @@ public class UserGroupsGetterService : IUserGroupsGetterService
{
return await _context.GroupMemberships
.AsNoTracking()
.Where(m => m.UserId == userId)
.Where(m => m.UserId == userId && !m.IsBanned)
.Select(m => m.ChatGroup)
.ToListAsync();
}
}
}
@@ -28,8 +28,10 @@ public class AccesserToDownloadMediaService : IAccesserToDownloadMedia
return media.OwnerType switch
{
MediaOwnerType.Avatar => true, // media.OwnerId == userId
MediaOwnerType.GroupAvatar => await _dbContext.GroupMemberships
.AnyAsync(gm => gm.GroupId == media.OwnerId && gm.UserId == userId && !gm.IsBanned),
MediaOwnerType.GroupAvatar => await _dbContext.ChatGroups.AnyAsync(g => g.Id == media.OwnerId &&
!_dbContext.GroupMemberships.Any(m => m.GroupId == g.Id && m.UserId == userId && m.IsBanned) &&
((!g.IsPrivate && g.ImageId == mediaId) || _dbContext.GroupMemberships
.Any(m => m.GroupId == g.Id && m.UserId == userId && !m.IsBanned))),
MediaOwnerType.Message => await _dbContext.MediaAttachments
.AnyAsync(ma =>
@@ -2,6 +2,7 @@ using Govor.Application.Messages.Parameters;
using Microsoft.EntityFrameworkCore;
using Govor.Domain;
using Govor.Domain.Models.Messages;
using Govor.Application.Groups;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
@@ -24,6 +25,25 @@ public class MessageEditingService : IMessageEditingService
}
public async Task<EditMessageResult> EditMessageAsync(EditMessage editParams)
{
var target = await _dbContext.Messages.AsNoTracking().FirstOrDefaultAsync(m => m.Id == editParams.MessageId);
if (target?.RecipientType != RecipientType.Group) return await EditCoreAsync(editParams);
return await _dbContext.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await _dbContext.Database.BeginTransactionAsync();
try
{
await _dbContext.ChatGroups.Where(g => g.Id == target.RecipientId)
.ExecuteUpdateAsync(s => s.SetProperty(g => g.Name, g => g.Name));
var result = await EditCoreAsync(editParams);
if (result.IsSuccess) await transaction.CommitAsync();
return result;
}
catch { _dbContext.ChangeTracker.Clear(); throw; }
});
}
private async Task<EditMessageResult> EditCoreAsync(EditMessage editParams)
{
var message = await _dbContext.Messages
.Include(m => m.MediaAttachments)
@@ -38,7 +58,10 @@ public class MessageEditingService : IMessageEditingService
}
if (message.SenderId != editParams.EditorId || !await _dbContext.HasChatAccessAsync(
editParams.EditorId, message.RecipientId, message.RecipientType))
editParams.EditorId, message.RecipientId, message.RecipientType) ||
(message.RecipientType == RecipientType.Group &&
await _dbContext.ChatGroups.AnyAsync(g => g.Id == message.RecipientId && g.IsChannel) &&
!await _dbContext.IsGroupAdministratorAsync(message.RecipientId, editParams.EditorId)))
{
_logger.LogWarning(
"User {EditorId} unauthorized to edit message {MessageId}",
@@ -1,6 +1,7 @@
using DeleteMessage = Govor.Application.Messages.Parameters.DeleteMessage;
using Govor.Domain;
using Govor.Domain.Common;
using Govor.Application.Groups;
using Govor.Domain.Models.Messages;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
@@ -20,6 +21,25 @@ public class MessageRemovingService : IMessageRemovingService
}
public async Task<Result<Message, Error>> DeleteMessageAsync(DeleteMessage deleteParams)
{
var target = await _govorDbContext.Messages.AsNoTracking().FirstOrDefaultAsync(m => m.Id == deleteParams.MessageId);
if (target?.RecipientType != RecipientType.Group) return await DeleteCoreAsync(deleteParams);
return await _govorDbContext.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await _govorDbContext.Database.BeginTransactionAsync();
try
{
await _govorDbContext.ChatGroups.Where(g => g.Id == target.RecipientId)
.ExecuteUpdateAsync(s => s.SetProperty(g => g.Name, g => g.Name));
var result = await DeleteCoreAsync(deleteParams);
if (result.IsSuccess) await transaction.CommitAsync();
return result;
}
catch { _govorDbContext.ChangeTracker.Clear(); throw; }
});
}
private async Task<Result<Message, Error>> DeleteCoreAsync(DeleteMessage deleteParams)
{
var message = await _govorDbContext.Messages.FirstOrDefaultAsync(m => m.Id == deleteParams.MessageId);
if (message is null)
@@ -36,8 +56,7 @@ public class MessageRemovingService : IMessageRemovingService
var canDelete = message.SenderId == deleteParams.DeleterId ||
(message.RecipientType == RecipientType.Group &&
await _govorDbContext.GroupAdmins.AnyAsync(a =>
a.GroupId == message.RecipientId && a.UserId == deleteParams.DeleterId));
await _govorDbContext.IsGroupAdministratorAsync(message.RecipientId, deleteParams.DeleterId));
if (!canDelete)
return Result.Failure<Message>(Error.Forbidden("Message.Remove.AccessDenied",
"Only the author or a group administrator can delete this message."));
@@ -3,6 +3,7 @@ using Microsoft.EntityFrameworkCore;
using Govor.Domain;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models;
using Govor.Application.Groups;
using Microsoft.Extensions.Logging;
namespace Govor.Application.Messages;
@@ -19,6 +20,30 @@ public class MessageSendingService : IMessageSendingService
}
public async Task<SendMessageResult> SendMessageAsync(SendMessage sendParams)
{
var operationId = Guid.NewGuid();
if (sendParams.RecipientType != RecipientType.Group)
return await SendCoreAsync(sendParams, operationId);
return await _dbContext.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
{
await using var transaction = await _dbContext.Database.BeginTransactionAsync();
try
{
// Same group lock as moderation: bans/demotion cannot race a channel post.
await _dbContext.ChatGroups.Where(g => g.Id == sendParams.RecipientId)
.ExecuteUpdateAsync(s => s.SetProperty(g => g.Name, g => g.Name));
var completed = await _dbContext.Messages.AsNoTracking().Include(m => m.MediaAttachments)
.FirstOrDefaultAsync(m => m.Id == operationId);
if (completed is not null) return new SendMessageResult(true, null, completed);
var result = await SendCoreAsync(sendParams, operationId);
if (result.IsSuccess) await transaction.CommitAsync();
return result;
}
catch { _dbContext.ChangeTracker.Clear(); throw; }
});
}
private async Task<SendMessageResult> SendCoreAsync(SendMessage sendParams, Guid operationId)
{
var media = sendParams.Media?.ToArray() ?? [];
if ((string.IsNullOrWhiteSpace(sendParams.EncryptContent) && media.Length == 0) ||
@@ -49,7 +74,7 @@ public class MessageSendingService : IMessageSendingService
m.RecipientType == sendParams.RecipientType))
return new SendMessageResult(false, new ArgumentException("Reply must belong to the same chat."), default);
var messageId = Guid.NewGuid();
var messageId = operationId;
var message = new Message
{
Id = messageId,
@@ -98,8 +123,7 @@ public class MessageSendingService : IMessageSendingService
var isMember = await _dbContext.GroupMemberships.AnyAsync(gm => gm.UserId == userId && gm.GroupId == groupId && !gm.IsBanned);
if (!isMember) return (false, "Sender is not a member of the group.");
if (group.IsChannel && !await _dbContext.GroupAdmins.AnyAsync(a =>
a.GroupId == groupId && a.UserId == userId))
if (group.IsChannel && !await _dbContext.IsGroupAdministratorAsync(groupId, userId))
return (false, "Only channel administrators can send messages.");
return (true, null);
@@ -1,5 +1,6 @@
using Govor.Application.Infrastructure.Common;
using Govor.Application.Messages;
using Govor.Application.Groups;
using Govor.Domain;
using Govor.Domain.Common;
using Govor.Domain.Models.Messages;
@@ -117,7 +118,7 @@ public class MessageReactionService(GovorDbContext context, INowDateTimeProvider
ChannelReactionMode mode, IReadOnlyCollection<Guid> reactionIds)
{
if (!await context.HasChatAccessAsync(userId, groupId, RecipientType.Group) ||
!await context.GroupAdmins.AnyAsync(a => a.GroupId == groupId && a.UserId == userId))
!await context.IsGroupAdministratorAsync(groupId, 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))
@@ -131,7 +132,7 @@ public class MessageReactionService(GovorDbContext context, INowDateTimeProvider
.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))
!await context.IsGroupAdministratorAsync(groupId, 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."));