feat: add tenant admin direct operations endpoints
This commit is contained in:
xiong
896
Tiku.Infrastructure/TenantAdmin/TenantAdminDirectService.cs
Normal file
896
Tiku.Infrastructure/TenantAdmin/TenantAdminDirectService.cs
Normal file
@@ -0,0 +1,896 @@
|
||||
using System.Text.Json;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Tiku.Application.Catalog;
|
||||
using Tiku.Application.Content;
|
||||
using Tiku.Application.TenantAdmin;
|
||||
using Tiku.Domain.Catalog;
|
||||
using Tiku.Domain.Common;
|
||||
using Tiku.Domain.Identity;
|
||||
using Tiku.Domain.Operations;
|
||||
using Tiku.Domain.Tenancy;
|
||||
using Tiku.Infrastructure.Persistence;
|
||||
|
||||
namespace Tiku.Infrastructure.TenantAdmin;
|
||||
|
||||
public sealed class TenantAdminDirectService(TikuDbContext dbContext) : ITenantAdminDirectService
|
||||
{
|
||||
public async Task<TenantAdminClassList> GetClassesAsync(
|
||||
TenantAdminActor actor,
|
||||
TenantAdminClassFilter filter,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var query = dbContext.TenantClasses.AsNoTracking().Where(item => item.TenantId == actor.TenantId);
|
||||
if (filter.RegionId.HasValue)
|
||||
{
|
||||
query = query.Where(item => item.RegionId == filter.RegionId.Value);
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(filter.Status))
|
||||
{
|
||||
query = query.Where(item => item.Status == ParseEnum<TenantRecordStatus>(filter.Status, "invalid_class_status"));
|
||||
}
|
||||
else
|
||||
{
|
||||
query = query.Where(item => item.Status != TenantRecordStatus.Archived);
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(filter.Keyword))
|
||||
{
|
||||
var keyword = filter.Keyword.Trim();
|
||||
query = query.Where(item =>
|
||||
item.Name.Contains(keyword) ||
|
||||
(item.Code != null && item.Code.Contains(keyword)));
|
||||
}
|
||||
|
||||
var items = await query
|
||||
.OrderBy(item => item.SortOrder)
|
||||
.ThenByDescending(item => item.CreatedAt)
|
||||
.Take(ResolveLimit(filter.Limit))
|
||||
.Select(item => new
|
||||
{
|
||||
Class = item,
|
||||
RegionName = dbContext.Regions
|
||||
.Where(region => region.TenantId == actor.TenantId && region.Id == item.RegionId)
|
||||
.Select(region => region.Name)
|
||||
.FirstOrDefault(),
|
||||
StudentCount = dbContext.TenantClassMembers.Count(member =>
|
||||
member.TenantId == actor.TenantId &&
|
||||
member.ClassId == item.Id &&
|
||||
member.Status == TenantClassMemberStatus.Active &&
|
||||
member.MemberType == TenantClassMemberType.Student),
|
||||
StaffCount = dbContext.TenantClassMembers.Count(member =>
|
||||
member.TenantId == actor.TenantId &&
|
||||
member.ClassId == item.Id &&
|
||||
member.Status == TenantClassMemberStatus.Active &&
|
||||
member.MemberType != TenantClassMemberType.Student)
|
||||
})
|
||||
.ToArrayAsync(cancellationToken);
|
||||
|
||||
return new TenantAdminClassList(
|
||||
items.Select(item => ToClassItem(item.Class, item.RegionName, item.StudentCount, item.StaffCount)).ToArray(),
|
||||
Scoped: false);
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminClassItem>> UpsertClassAsync(
|
||||
TenantAdminActor actor,
|
||||
UpsertTenantAdminClassCommand command,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(command.Name);
|
||||
await AssertReferenceAsync<Region>(actor.TenantId, command.RegionId, "region_not_found", cancellationToken);
|
||||
|
||||
var item = await ResolveTenantEntityAsync(dbContext.TenantClasses, actor.TenantId, command.Id, command.LegacyId, cancellationToken);
|
||||
var isNew = item is null;
|
||||
item ??= new TenantClass { Id = command.Id ?? Guid.NewGuid(), TenantId = actor.TenantId, CreatedBy = actor.UserId };
|
||||
item.RegionId = command.RegionId;
|
||||
item.LegacyId = Normalize(command.LegacyId);
|
||||
item.Code = Normalize(command.Code);
|
||||
item.Name = command.Name.Trim();
|
||||
item.Description = Normalize(command.Description);
|
||||
item.Status = ParseEnum(command.Status, TenantRecordStatus.Active, "invalid_class_status");
|
||||
item.SortOrder = command.Order ?? item.SortOrder;
|
||||
item.Metadata = JsonObjectOrDefault(command.Metadata);
|
||||
item.UpdatedBy = actor.UserId;
|
||||
|
||||
if (isNew)
|
||||
{
|
||||
dbContext.TenantClasses.Add(item);
|
||||
}
|
||||
|
||||
await AddAuditAsync(actor, "tenant.class.upserted", "tenant_classes", item.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
|
||||
var regionName = item.RegionId.HasValue
|
||||
? await dbContext.Regions
|
||||
.Where(region => region.TenantId == actor.TenantId && region.Id == item.RegionId.Value)
|
||||
.Select(region => region.Name)
|
||||
.FirstOrDefaultAsync(cancellationToken)
|
||||
: null;
|
||||
return new ContentManagementResult<TenantAdminClassItem>(ToClassItem(item, regionName, 0, 0));
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminClassItem>> DisableClassAsync(
|
||||
TenantAdminActor actor,
|
||||
Guid classId,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var item = await dbContext.TenantClasses
|
||||
.FirstOrDefaultAsync(entity => entity.TenantId == actor.TenantId && entity.Id == classId, cancellationToken);
|
||||
if (item is null)
|
||||
{
|
||||
throw new TenantAdminDirectException("Class was not found.", "class_not_found");
|
||||
}
|
||||
|
||||
item.Status = TenantRecordStatus.Disabled;
|
||||
item.UpdatedBy = actor.UserId;
|
||||
await AddAuditAsync(actor, "tenant.class.disabled", "tenant_classes", item.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
return new ContentManagementResult<TenantAdminClassItem>(ToClassItem(item, null, 0, 0));
|
||||
}
|
||||
|
||||
public async Task<CatalogList<TenantAdminClassMemberItem>> GetClassMembersAsync(
|
||||
TenantAdminActor actor,
|
||||
TenantAdminClassMemberFilter filter,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
await AssertClassAsync(actor.TenantId, filter.ClassId, cancellationToken);
|
||||
var query = dbContext.TenantClassMembers.AsNoTracking()
|
||||
.Where(item => item.TenantId == actor.TenantId && item.ClassId == filter.ClassId);
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(filter.MemberType))
|
||||
{
|
||||
query = query.Where(item => item.MemberType == ParseEnum<TenantClassMemberType>(filter.MemberType, "invalid_class_member_type"));
|
||||
}
|
||||
|
||||
query = query.Where(item => item.Status == ParseEnum(filter.Status, TenantClassMemberStatus.Active, "invalid_class_member_status"));
|
||||
|
||||
var items = await query
|
||||
.OrderBy(item => item.MemberType == TenantClassMemberType.HeadTeacher ? 0 :
|
||||
item.MemberType == TenantClassMemberType.Teacher ? 1 :
|
||||
item.MemberType == TenantClassMemberType.Assistant ? 2 : 9)
|
||||
.ThenBy(item => item.JoinedAt)
|
||||
.Take(ResolveLimit(filter.Limit))
|
||||
.Join(
|
||||
dbContext.Users.AsNoTracking(),
|
||||
member => member.UserId,
|
||||
user => user.Id,
|
||||
(member, user) => ToClassMemberItem(member, ToUserSummary(user)))
|
||||
.ToArrayAsync(cancellationToken);
|
||||
|
||||
return new CatalogList<TenantAdminClassMemberItem>(items);
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminClassMemberItem>> UpsertClassMemberAsync(
|
||||
TenantAdminActor actor,
|
||||
UpsertTenantAdminClassMemberCommand command,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
await AssertClassAsync(actor.TenantId, command.ClassId, cancellationToken);
|
||||
var memberType = ParseEnum(command.MemberType, TenantClassMemberType.Student, "invalid_class_member_type");
|
||||
var status = ParseEnum(command.Status, TenantClassMemberStatus.Active, "invalid_class_member_status");
|
||||
var user = await ResolveUserAsync(command.User, memberType == TenantClassMemberType.Student ? "student" : "teacher", cancellationToken);
|
||||
await EnsureMembershipAsync(actor.TenantId, user.Id, memberType == TenantClassMemberType.Student ? TenantRole.Student : TenantRole.Teacher, cancellationToken);
|
||||
if (memberType == TenantClassMemberType.Student)
|
||||
{
|
||||
await EnsureStudentProfileAsync(actor.TenantId, user.Id, null, null, null, null, JsonDefaults.Object(), JsonDefaults.Object(), JsonDefaults.Object(), cancellationToken);
|
||||
}
|
||||
|
||||
var item = await dbContext.TenantClassMembers.FirstOrDefaultAsync(member =>
|
||||
member.TenantId == actor.TenantId &&
|
||||
member.ClassId == command.ClassId &&
|
||||
member.UserId == user.Id &&
|
||||
member.MemberType == memberType,
|
||||
cancellationToken);
|
||||
var isNew = item is null;
|
||||
item ??= new TenantClassMember
|
||||
{
|
||||
TenantId = actor.TenantId,
|
||||
ClassId = command.ClassId,
|
||||
UserId = user.Id,
|
||||
MemberType = memberType,
|
||||
CreatedBy = actor.UserId
|
||||
};
|
||||
item.Status = status;
|
||||
item.LeftAt = status is TenantClassMemberStatus.Active ? null : DateTimeOffset.UtcNow;
|
||||
item.Metadata = JsonObjectOrDefault(command.Metadata);
|
||||
item.UpdatedBy = actor.UserId;
|
||||
if (isNew)
|
||||
{
|
||||
dbContext.TenantClassMembers.Add(item);
|
||||
}
|
||||
|
||||
await AddAuditAsync(actor, "tenant.class_member.upserted", "tenant_class_members", item.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
return new ContentManagementResult<TenantAdminClassMemberItem>(ToClassMemberItem(item, ToUserSummary(user)));
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminClassMemberItem>> RemoveClassMemberAsync(
|
||||
TenantAdminActor actor,
|
||||
Guid classMemberId,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var item = await dbContext.TenantClassMembers
|
||||
.FirstOrDefaultAsync(member => member.TenantId == actor.TenantId && member.Id == classMemberId, cancellationToken);
|
||||
if (item is null)
|
||||
{
|
||||
throw new TenantAdminDirectException("Class member was not found.", "class_member_not_found");
|
||||
}
|
||||
|
||||
var user = await dbContext.Users.SingleAsync(user => user.Id == item.UserId, cancellationToken);
|
||||
item.Status = TenantClassMemberStatus.Removed;
|
||||
item.LeftAt = DateTimeOffset.UtcNow;
|
||||
item.UpdatedBy = actor.UserId;
|
||||
await AddAuditAsync(actor, "tenant.class_member.removed", "tenant_class_members", item.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
return new ContentManagementResult<TenantAdminClassMemberItem>(ToClassMemberItem(item, ToUserSummary(user)));
|
||||
}
|
||||
|
||||
public async Task<TenantAdminStudentList> GetStudentsAsync(
|
||||
TenantAdminActor actor,
|
||||
TenantAdminStudentFilter filter,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var status = ParseEnum(filter.Status, MembershipStatus.Active, "invalid_student_status");
|
||||
var query = dbContext.TenantMemberships.AsNoTracking()
|
||||
.Where(item => item.TenantId == actor.TenantId && item.Role == TenantRole.Student && item.Status == status);
|
||||
|
||||
if (filter.ClassId.HasValue)
|
||||
{
|
||||
await AssertClassAsync(actor.TenantId, filter.ClassId.Value, cancellationToken);
|
||||
query = query.Where(item => dbContext.TenantClassMembers.Any(member =>
|
||||
member.TenantId == actor.TenantId &&
|
||||
member.ClassId == filter.ClassId.Value &&
|
||||
member.UserId == item.UserId &&
|
||||
member.MemberType == TenantClassMemberType.Student &&
|
||||
member.Status == TenantClassMemberStatus.Active));
|
||||
}
|
||||
|
||||
if (filter.RegionId.HasValue)
|
||||
{
|
||||
query = query.Where(item => dbContext.StudentProfiles.Any(profile =>
|
||||
profile.TenantId == actor.TenantId &&
|
||||
profile.UserId == item.UserId &&
|
||||
profile.RegionId == filter.RegionId.Value));
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(filter.Keyword))
|
||||
{
|
||||
var keyword = filter.Keyword.Trim();
|
||||
query = query.Where(item => dbContext.Users.Any(user =>
|
||||
user.Id == item.UserId &&
|
||||
((user.Username != null && user.Username.Contains(keyword)) ||
|
||||
(user.Phone != null && user.Phone.Contains(keyword)) ||
|
||||
(user.Email != null && user.Email.Contains(keyword)) ||
|
||||
(user.Name != null && user.Name.Contains(keyword)))));
|
||||
}
|
||||
|
||||
var memberships = await query
|
||||
.OrderByDescending(item => item.CreatedAt)
|
||||
.Take(ResolveLimit(filter.Limit))
|
||||
.ToArrayAsync(cancellationToken);
|
||||
var userIds = memberships.Select(item => item.UserId).ToArray();
|
||||
var users = await dbContext.Users.AsNoTracking()
|
||||
.Where(user => userIds.Contains(user.Id))
|
||||
.ToDictionaryAsync(user => user.Id, cancellationToken);
|
||||
var profiles = await dbContext.StudentProfiles.AsNoTracking()
|
||||
.Where(profile => profile.TenantId == actor.TenantId && userIds.Contains(profile.UserId))
|
||||
.ToDictionaryAsync(profile => profile.UserId, cancellationToken);
|
||||
var regions = await dbContext.Regions.AsNoTracking()
|
||||
.Where(region => region.TenantId == actor.TenantId)
|
||||
.ToDictionaryAsync(region => region.Id, region => region.Name, cancellationToken);
|
||||
var schools = await dbContext.Schools.AsNoTracking()
|
||||
.Where(school => school.TenantId == actor.TenantId)
|
||||
.ToDictionaryAsync(school => school.Id, school => school.Name, cancellationToken);
|
||||
var majors = await dbContext.Majors.AsNoTracking()
|
||||
.Where(major => major.TenantId == actor.TenantId)
|
||||
.ToDictionaryAsync(major => major.Id, major => major.Name, cancellationToken);
|
||||
var classes = await (
|
||||
from member in dbContext.TenantClassMembers.AsNoTracking()
|
||||
join tenantClass in dbContext.TenantClasses.AsNoTracking() on member.ClassId equals tenantClass.Id
|
||||
where member.TenantId == actor.TenantId &&
|
||||
tenantClass.TenantId == actor.TenantId &&
|
||||
userIds.Contains(member.UserId) &&
|
||||
member.Status == TenantClassMemberStatus.Active &&
|
||||
member.MemberType == TenantClassMemberType.Student
|
||||
orderby tenantClass.SortOrder, tenantClass.CreatedAt descending
|
||||
select new { member.UserId, member.MemberType, member.JoinedAt, ClassId = tenantClass.Id, tenantClass.Name, tenantClass.Code })
|
||||
.ToArrayAsync(cancellationToken);
|
||||
var classLookup = classes
|
||||
.GroupBy(item => item.UserId)
|
||||
.ToDictionary(
|
||||
group => group.Key,
|
||||
group => group.Select(item => new TenantAdminStudentClassSummary(
|
||||
item.ClassId,
|
||||
item.Name,
|
||||
item.Code,
|
||||
item.MemberType,
|
||||
item.JoinedAt)).ToArray() as IReadOnlyCollection<TenantAdminStudentClassSummary>);
|
||||
|
||||
return new TenantAdminStudentList(
|
||||
memberships.Select(membership =>
|
||||
{
|
||||
users.TryGetValue(membership.UserId, out var user);
|
||||
profiles.TryGetValue(membership.UserId, out var profile);
|
||||
classLookup.TryGetValue(membership.UserId, out var studentClasses);
|
||||
return ToStudentItem(
|
||||
membership,
|
||||
user ?? new User { Id = membership.UserId },
|
||||
profile,
|
||||
regions,
|
||||
schools,
|
||||
majors,
|
||||
studentClasses ?? []);
|
||||
}).ToArray(),
|
||||
Scoped: false);
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminStudentItem>> UpsertStudentAsync(
|
||||
TenantAdminActor actor,
|
||||
UpsertTenantAdminStudentCommand command,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
await AssertReferenceAsync<Region>(actor.TenantId, command.RegionId, "region_not_found", cancellationToken);
|
||||
await AssertReferenceAsync<School>(actor.TenantId, command.SelectedSchoolId, "school_not_found", cancellationToken);
|
||||
await AssertReferenceAsync<Major>(actor.TenantId, command.SelectedMajorId, "major_not_found", cancellationToken);
|
||||
var user = await ResolveUserAsync(command.User, "student", cancellationToken);
|
||||
if (command.RawProfile.ValueKind == JsonValueKind.Object)
|
||||
{
|
||||
user.RawProfile = command.RawProfile.Clone();
|
||||
}
|
||||
|
||||
var membership = await EnsureMembershipAsync(actor.TenantId, user.Id, TenantRole.Student, cancellationToken);
|
||||
var profile = await EnsureStudentProfileAsync(
|
||||
actor.TenantId,
|
||||
user.Id,
|
||||
command.RegionId,
|
||||
command.SelectedSchoolId,
|
||||
command.SelectedMajorId,
|
||||
Normalize(command.AvatarPreset),
|
||||
command.Stats,
|
||||
command.Progress,
|
||||
command.ModuleSelections,
|
||||
cancellationToken);
|
||||
|
||||
await AddAuditAsync(actor, "tenant.student.upserted", "student_profiles", profile.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
|
||||
return new ContentManagementResult<TenantAdminStudentItem>(
|
||||
ToStudentItem(
|
||||
membership,
|
||||
user,
|
||||
profile,
|
||||
new Dictionary<Guid, string>(),
|
||||
new Dictionary<Guid, string>(),
|
||||
new Dictionary<Guid, string>(),
|
||||
[]));
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminStudentStatusItem>> UpdateStudentStatusAsync(
|
||||
TenantAdminActor actor,
|
||||
UpdateTenantAdminStudentStatusCommand command,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var status = ParseEnum(command.Status, MembershipStatus.Active, "invalid_student_status");
|
||||
var membership = await dbContext.TenantMemberships
|
||||
.FirstOrDefaultAsync(item =>
|
||||
item.TenantId == actor.TenantId &&
|
||||
item.UserId == command.UserId &&
|
||||
item.Role == TenantRole.Student,
|
||||
cancellationToken);
|
||||
if (membership is null)
|
||||
{
|
||||
throw new TenantAdminDirectException("Student membership was not found.", "student_not_found");
|
||||
}
|
||||
|
||||
membership.Status = status;
|
||||
if (status != MembershipStatus.Active)
|
||||
{
|
||||
var now = DateTimeOffset.UtcNow;
|
||||
var sessions = await dbContext.AuthSessions
|
||||
.Where(session => session.TenantId == actor.TenantId && session.UserId == command.UserId && session.RevokedAt == null)
|
||||
.ToArrayAsync(cancellationToken);
|
||||
foreach (var session in sessions)
|
||||
{
|
||||
session.RevokedAt = now;
|
||||
}
|
||||
}
|
||||
|
||||
await AddAuditAsync(actor, "tenant.student.status_updated", "tenant_memberships", membership.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
return new ContentManagementResult<TenantAdminStudentStatusItem>(
|
||||
new TenantAdminStudentStatusItem(membership.Id, membership.UserId, membership.Role, membership.Status, membership.UpdatedAt));
|
||||
}
|
||||
|
||||
public async Task<CatalogList<TenantAdminStudentNoteItem>> GetStudentNotesAsync(
|
||||
TenantAdminActor actor,
|
||||
TenantAdminStudentActivityFilter filter,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var query = dbContext.TenantStudentNotes.AsNoTracking().Where(item => item.TenantId == actor.TenantId);
|
||||
if (filter.StudentUserId.HasValue)
|
||||
{
|
||||
query = query.Where(item => item.StudentUserId == filter.StudentUserId.Value);
|
||||
}
|
||||
|
||||
var items = await query
|
||||
.OrderByDescending(item => item.IsPinned)
|
||||
.ThenByDescending(item => item.CreatedAt)
|
||||
.Take(ResolveLimit(filter.Limit))
|
||||
.Select(item => ToNoteItem(item))
|
||||
.ToArrayAsync(cancellationToken);
|
||||
return new CatalogList<TenantAdminStudentNoteItem>(items);
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminStudentNoteItem>> UpsertStudentNoteAsync(
|
||||
TenantAdminActor actor,
|
||||
UpsertTenantAdminStudentNoteCommand command,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(command.Content);
|
||||
await AssertStudentAsync(actor.TenantId, command.StudentUserId, cancellationToken);
|
||||
var item = command.Id.HasValue
|
||||
? await dbContext.TenantStudentNotes.FirstOrDefaultAsync(note => note.TenantId == actor.TenantId && note.Id == command.Id.Value, cancellationToken)
|
||||
: null;
|
||||
var isNew = item is null;
|
||||
item ??= new TenantStudentNote { Id = command.Id ?? Guid.NewGuid(), TenantId = actor.TenantId, StudentUserId = command.StudentUserId, CreatedBy = actor.UserId };
|
||||
item.NoteType = ParseEnum(command.NoteType, StudentNoteType.General, "invalid_student_note_type");
|
||||
item.Content = command.Content.Trim();
|
||||
item.Visibility = ParseEnum(command.Visibility, StudentNoteVisibility.TenantStaff, "invalid_student_note_visibility");
|
||||
item.IsPinned = command.IsPinned ?? item.IsPinned;
|
||||
item.Metadata = JsonObjectOrDefault(command.Metadata);
|
||||
item.UpdatedBy = actor.UserId;
|
||||
if (isNew)
|
||||
{
|
||||
dbContext.TenantStudentNotes.Add(item);
|
||||
}
|
||||
|
||||
await AddAuditAsync(actor, "tenant.student_note.upserted", "tenant_student_notes", item.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
return new ContentManagementResult<TenantAdminStudentNoteItem>(ToNoteItem(item));
|
||||
}
|
||||
|
||||
public async Task<CatalogList<TenantAdminStudentFollowupItem>> GetStudentFollowupsAsync(
|
||||
TenantAdminActor actor,
|
||||
TenantAdminStudentActivityFilter filter,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var query = dbContext.TenantStudentFollowups.AsNoTracking().Where(item => item.TenantId == actor.TenantId);
|
||||
if (filter.StudentUserId.HasValue)
|
||||
{
|
||||
query = query.Where(item => item.StudentUserId == filter.StudentUserId.Value);
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(filter.Status))
|
||||
{
|
||||
query = query.Where(item => item.Status == ParseEnum<StudentFollowupStatus>(filter.Status, "invalid_student_followup_status"));
|
||||
}
|
||||
|
||||
var items = await query
|
||||
.OrderBy(item => item.Status == StudentFollowupStatus.Done || item.Status == StudentFollowupStatus.Cancelled)
|
||||
.ThenBy(item => item.DueAt ?? DateTimeOffset.MaxValue)
|
||||
.ThenByDescending(item => item.CreatedAt)
|
||||
.Take(ResolveLimit(filter.Limit))
|
||||
.Select(item => ToFollowupItem(item))
|
||||
.ToArrayAsync(cancellationToken);
|
||||
return new CatalogList<TenantAdminStudentFollowupItem>(items);
|
||||
}
|
||||
|
||||
public async Task<ContentManagementResult<TenantAdminStudentFollowupItem>> UpsertStudentFollowupAsync(
|
||||
TenantAdminActor actor,
|
||||
UpsertTenantAdminStudentFollowupCommand command,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(command.Title);
|
||||
await AssertStudentAsync(actor.TenantId, command.StudentUserId, cancellationToken);
|
||||
await AssertClassAsync(actor.TenantId, command.ClassId, cancellationToken);
|
||||
await AssertTenantMemberAsync(actor.TenantId, command.AssignedToUserId, cancellationToken);
|
||||
|
||||
var item = command.Id.HasValue
|
||||
? await dbContext.TenantStudentFollowups.FirstOrDefaultAsync(followup => followup.TenantId == actor.TenantId && followup.Id == command.Id.Value, cancellationToken)
|
||||
: null;
|
||||
var isNew = item is null;
|
||||
item ??= new TenantStudentFollowup
|
||||
{
|
||||
Id = command.Id ?? Guid.NewGuid(),
|
||||
TenantId = actor.TenantId,
|
||||
StudentUserId = command.StudentUserId,
|
||||
CreatedBy = actor.UserId
|
||||
};
|
||||
item.AssignedToUserId = command.AssignedToUserId;
|
||||
item.ClassId = command.ClassId;
|
||||
item.Title = command.Title.Trim();
|
||||
item.Description = Normalize(command.Description);
|
||||
item.FollowupType = ParseEnum(command.FollowupType, StudentFollowupType.Learning, "invalid_student_followup_type");
|
||||
item.Priority = ParseEnum(command.Priority, StudentFollowupPriority.Normal, "invalid_student_followup_priority");
|
||||
item.Status = ParseEnum(command.Status, StudentFollowupStatus.Open, "invalid_student_followup_status");
|
||||
item.DueAt = command.DueAt;
|
||||
item.CompletedAt = item.Status == StudentFollowupStatus.Done ? DateTimeOffset.UtcNow : null;
|
||||
item.CompletedBy = item.Status == StudentFollowupStatus.Done ? actor.UserId : null;
|
||||
item.Metadata = JsonObjectOrDefault(command.Metadata);
|
||||
item.UpdatedBy = actor.UserId;
|
||||
if (isNew)
|
||||
{
|
||||
dbContext.TenantStudentFollowups.Add(item);
|
||||
}
|
||||
|
||||
await AddAuditAsync(actor, "tenant.student_followup.upserted", "tenant_student_followups", item.Id, cancellationToken);
|
||||
await dbContext.SaveChangesAsync(cancellationToken);
|
||||
return new ContentManagementResult<TenantAdminStudentFollowupItem>(ToFollowupItem(item));
|
||||
}
|
||||
|
||||
private async Task<User> ResolveUserAsync(UserLookupCommand command, string primaryRole, CancellationToken cancellationToken)
|
||||
{
|
||||
User? user = null;
|
||||
if (command.UserId.HasValue)
|
||||
{
|
||||
user = await dbContext.Users.FirstOrDefaultAsync(item => item.Id == command.UserId.Value, cancellationToken);
|
||||
if (user is null)
|
||||
{
|
||||
throw new TenantAdminDirectException("User was not found.", "user_not_found");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
var phone = Normalize(command.Phone);
|
||||
var email = Normalize(command.Email);
|
||||
var username = Normalize(command.Username);
|
||||
user = await dbContext.Users.FirstOrDefaultAsync(item =>
|
||||
(phone != null && item.Phone == phone) ||
|
||||
(email != null && item.Email == email) ||
|
||||
(username != null && item.Username == username),
|
||||
cancellationToken);
|
||||
|
||||
if (user is null)
|
||||
{
|
||||
if (phone is null && email is null && username is null && Normalize(command.Name) is null)
|
||||
{
|
||||
throw new TenantAdminDirectException("userId, phone, email, username or name is required.", "user_required");
|
||||
}
|
||||
|
||||
user = new User
|
||||
{
|
||||
Username = username ?? phone ?? email,
|
||||
Email = email,
|
||||
Phone = phone,
|
||||
Name = Normalize(command.Name) ?? username ?? phone ?? email,
|
||||
PrimaryRole = primaryRole,
|
||||
RawProfile = JsonDefaults.Object()
|
||||
};
|
||||
dbContext.Users.Add(user);
|
||||
}
|
||||
}
|
||||
|
||||
user.Username = Normalize(command.Username) ?? user.Username;
|
||||
user.Email = Normalize(command.Email) ?? user.Email;
|
||||
user.Phone = Normalize(command.Phone) ?? user.Phone;
|
||||
user.Name = Normalize(command.Name) ?? user.Name;
|
||||
user.AvatarUrl = Normalize(command.AvatarUrl) ?? user.AvatarUrl;
|
||||
user.PrimaryRole = string.IsNullOrWhiteSpace(user.PrimaryRole) ? primaryRole : user.PrimaryRole;
|
||||
return user;
|
||||
}
|
||||
|
||||
private async Task<TenantMembership> EnsureMembershipAsync(
|
||||
Guid tenantId,
|
||||
Guid userId,
|
||||
TenantRole role,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var membership = await dbContext.TenantMemberships.FirstOrDefaultAsync(item =>
|
||||
item.TenantId == tenantId && item.UserId == userId && item.Role == role,
|
||||
cancellationToken);
|
||||
if (membership is null)
|
||||
{
|
||||
membership = new TenantMembership
|
||||
{
|
||||
TenantId = tenantId,
|
||||
UserId = userId,
|
||||
Role = role,
|
||||
Status = MembershipStatus.Active,
|
||||
Permissions = JsonDefaults.Object()
|
||||
};
|
||||
dbContext.TenantMemberships.Add(membership);
|
||||
}
|
||||
else
|
||||
{
|
||||
membership.Status = MembershipStatus.Active;
|
||||
}
|
||||
|
||||
return membership;
|
||||
}
|
||||
|
||||
private async Task<StudentProfile> EnsureStudentProfileAsync(
|
||||
Guid tenantId,
|
||||
Guid userId,
|
||||
Guid? regionId,
|
||||
Guid? schoolId,
|
||||
Guid? majorId,
|
||||
string? avatarPreset,
|
||||
JsonElement stats,
|
||||
JsonElement progress,
|
||||
JsonElement moduleSelections,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var profile = await dbContext.StudentProfiles.FirstOrDefaultAsync(item =>
|
||||
item.TenantId == tenantId && item.UserId == userId,
|
||||
cancellationToken);
|
||||
if (profile is null)
|
||||
{
|
||||
profile = new StudentProfile
|
||||
{
|
||||
TenantId = tenantId,
|
||||
UserId = userId,
|
||||
Stats = JsonDefaults.Object(),
|
||||
Progress = JsonDefaults.Object(),
|
||||
ModuleSelections = JsonDefaults.Object(),
|
||||
RecentActivities = JsonDefaults.Array()
|
||||
};
|
||||
dbContext.StudentProfiles.Add(profile);
|
||||
}
|
||||
|
||||
profile.RegionId = regionId ?? profile.RegionId;
|
||||
profile.SelectedSchoolId = schoolId ?? profile.SelectedSchoolId;
|
||||
profile.SelectedMajorId = majorId ?? profile.SelectedMajorId;
|
||||
profile.AvatarPreset = avatarPreset ?? profile.AvatarPreset;
|
||||
profile.Stats = JsonObjectOrDefault(stats);
|
||||
profile.Progress = JsonObjectOrDefault(progress);
|
||||
profile.ModuleSelections = JsonObjectOrDefault(moduleSelections);
|
||||
return profile;
|
||||
}
|
||||
|
||||
private async Task AssertStudentAsync(Guid tenantId, Guid userId, CancellationToken cancellationToken)
|
||||
{
|
||||
var exists = await dbContext.TenantMemberships.AnyAsync(
|
||||
item => item.TenantId == tenantId && item.UserId == userId && item.Role == TenantRole.Student,
|
||||
cancellationToken);
|
||||
if (!exists)
|
||||
{
|
||||
throw new TenantAdminDirectException("Student was not found.", "student_not_found");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task AssertTenantMemberAsync(Guid tenantId, Guid? userId, CancellationToken cancellationToken)
|
||||
{
|
||||
if (!userId.HasValue)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var exists = await dbContext.TenantMemberships.AnyAsync(
|
||||
item => item.TenantId == tenantId && item.UserId == userId.Value && item.Status == MembershipStatus.Active,
|
||||
cancellationToken);
|
||||
if (!exists)
|
||||
{
|
||||
throw new TenantAdminDirectException("Tenant member was not found.", "tenant_member_not_found");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task AssertClassAsync(Guid tenantId, Guid? classId, CancellationToken cancellationToken)
|
||||
{
|
||||
if (!classId.HasValue)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var exists = await dbContext.TenantClasses.AnyAsync(
|
||||
item => item.TenantId == tenantId && item.Id == classId.Value,
|
||||
cancellationToken);
|
||||
if (!exists)
|
||||
{
|
||||
throw new TenantAdminDirectException("Class was not found.", "class_not_found");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task AssertReferenceAsync<TEntity>(
|
||||
Guid tenantId,
|
||||
Guid? id,
|
||||
string code,
|
||||
CancellationToken cancellationToken)
|
||||
where TEntity : TenantEntity
|
||||
{
|
||||
if (!id.HasValue)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var exists = await dbContext.Set<TEntity>().AnyAsync(entity => entity.TenantId == tenantId && entity.Id == id.Value, cancellationToken);
|
||||
if (!exists)
|
||||
{
|
||||
throw new TenantAdminDirectException("Referenced entity was not found in this tenant.", code);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<TEntity?> ResolveTenantEntityAsync<TEntity>(
|
||||
DbSet<TEntity> set,
|
||||
Guid tenantId,
|
||||
Guid? id,
|
||||
string? legacyId,
|
||||
CancellationToken cancellationToken)
|
||||
where TEntity : AuditableTenantEntity
|
||||
{
|
||||
if (id.HasValue)
|
||||
{
|
||||
return await set.FirstOrDefaultAsync(entity => entity.TenantId == tenantId && entity.Id == id.Value, cancellationToken);
|
||||
}
|
||||
|
||||
legacyId = Normalize(legacyId);
|
||||
if (legacyId is null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
return typeof(TEntity).GetProperty("LegacyId") is null
|
||||
? null
|
||||
: await set.FirstOrDefaultAsync(
|
||||
entity => entity.TenantId == tenantId && EF.Property<string?>(entity, "LegacyId") == legacyId,
|
||||
cancellationToken);
|
||||
}
|
||||
|
||||
private async Task AddAuditAsync(
|
||||
TenantAdminActor actor,
|
||||
string action,
|
||||
string targetType,
|
||||
Guid targetId,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
dbContext.AuditLogs.Add(new AuditLog
|
||||
{
|
||||
TenantId = actor.TenantId,
|
||||
ActorUserId = actor.UserId,
|
||||
Action = action,
|
||||
TargetType = targetType,
|
||||
TargetId = targetId.ToString(),
|
||||
Details = JsonDefaults.Object()
|
||||
});
|
||||
await Task.CompletedTask.WaitAsync(cancellationToken);
|
||||
}
|
||||
|
||||
private static TenantAdminClassItem ToClassItem(TenantClass item, string? regionName, int studentCount, int staffCount)
|
||||
{
|
||||
return new TenantAdminClassItem(
|
||||
item.Id,
|
||||
item.RegionId,
|
||||
regionName,
|
||||
item.LegacyId,
|
||||
item.Code,
|
||||
item.Name,
|
||||
item.Description,
|
||||
item.Status,
|
||||
item.SortOrder,
|
||||
item.Metadata,
|
||||
studentCount,
|
||||
staffCount,
|
||||
item.CreatedAt,
|
||||
item.UpdatedAt);
|
||||
}
|
||||
|
||||
private static TenantAdminClassMemberItem ToClassMemberItem(TenantClassMember item, TenantAdminUserSummary user)
|
||||
{
|
||||
return new TenantAdminClassMemberItem(
|
||||
item.Id,
|
||||
item.ClassId,
|
||||
item.UserId,
|
||||
item.MemberType,
|
||||
item.Status,
|
||||
item.JoinedAt,
|
||||
item.LeftAt,
|
||||
item.Metadata,
|
||||
user);
|
||||
}
|
||||
|
||||
private static TenantAdminStudentItem ToStudentItem(
|
||||
TenantMembership membership,
|
||||
User user,
|
||||
StudentProfile? profile,
|
||||
IReadOnlyDictionary<Guid, string> regions,
|
||||
IReadOnlyDictionary<Guid, string> schools,
|
||||
IReadOnlyDictionary<Guid, string> majors,
|
||||
IReadOnlyCollection<TenantAdminStudentClassSummary> classes)
|
||||
{
|
||||
return new TenantAdminStudentItem(
|
||||
membership.Id,
|
||||
membership.UserId,
|
||||
membership.Status,
|
||||
ToUserSummary(user),
|
||||
profile?.Id,
|
||||
profile?.AvatarPreset ?? "male",
|
||||
profile?.RegionId,
|
||||
profile?.RegionId is Guid regionId && regions.TryGetValue(regionId, out var regionName) ? regionName : null,
|
||||
profile?.SelectedSchoolId,
|
||||
profile?.SelectedSchoolId is Guid schoolId && schools.TryGetValue(schoolId, out var schoolName) ? schoolName : null,
|
||||
profile?.SelectedMajorId,
|
||||
profile?.SelectedMajorId is Guid majorId && majors.TryGetValue(majorId, out var majorName) ? majorName : null,
|
||||
profile?.Stats ?? JsonDefaults.Object(),
|
||||
profile?.Progress ?? JsonDefaults.Object(),
|
||||
profile?.ModuleSelections ?? JsonDefaults.Object(),
|
||||
classes,
|
||||
membership.CreatedAt,
|
||||
membership.UpdatedAt);
|
||||
}
|
||||
|
||||
private static TenantAdminUserSummary ToUserSummary(User user)
|
||||
{
|
||||
return new TenantAdminUserSummary(
|
||||
user.Id,
|
||||
user.Username,
|
||||
user.Email,
|
||||
user.Phone,
|
||||
user.Name,
|
||||
user.AvatarUrl,
|
||||
user.PrimaryRole);
|
||||
}
|
||||
|
||||
private static TenantAdminStudentNoteItem ToNoteItem(TenantStudentNote item)
|
||||
{
|
||||
return new TenantAdminStudentNoteItem(
|
||||
item.Id,
|
||||
item.StudentUserId,
|
||||
item.NoteType,
|
||||
item.Content,
|
||||
item.Visibility,
|
||||
item.IsPinned,
|
||||
item.Metadata,
|
||||
item.CreatedBy,
|
||||
item.UpdatedBy,
|
||||
item.CreatedAt,
|
||||
item.UpdatedAt);
|
||||
}
|
||||
|
||||
private static TenantAdminStudentFollowupItem ToFollowupItem(TenantStudentFollowup item)
|
||||
{
|
||||
return new TenantAdminStudentFollowupItem(
|
||||
item.Id,
|
||||
item.StudentUserId,
|
||||
item.AssignedToUserId,
|
||||
item.ClassId,
|
||||
item.Title,
|
||||
item.Description,
|
||||
item.FollowupType,
|
||||
item.Priority,
|
||||
item.Status,
|
||||
item.DueAt,
|
||||
item.CompletedAt,
|
||||
item.CompletedBy,
|
||||
item.Metadata,
|
||||
item.CreatedBy,
|
||||
item.UpdatedBy,
|
||||
item.CreatedAt,
|
||||
item.UpdatedAt);
|
||||
}
|
||||
|
||||
private static int ResolveLimit(int? limit)
|
||||
{
|
||||
return Math.Clamp(limit ?? 100, 1, 500);
|
||||
}
|
||||
|
||||
private static string? Normalize(string? value)
|
||||
{
|
||||
return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
|
||||
}
|
||||
|
||||
private static JsonElement JsonObjectOrDefault(JsonElement value)
|
||||
{
|
||||
return value.ValueKind == JsonValueKind.Object ? value.Clone() : JsonDefaults.Object();
|
||||
}
|
||||
|
||||
private static TEnum ParseEnum<TEnum>(string? value, TEnum fallback, string code)
|
||||
where TEnum : struct, Enum
|
||||
{
|
||||
return string.IsNullOrWhiteSpace(value) ? fallback : ParseEnum<TEnum>(value, code);
|
||||
}
|
||||
|
||||
private static TEnum ParseEnum<TEnum>(string value, string code)
|
||||
where TEnum : struct, Enum
|
||||
{
|
||||
var normalized = value.Replace("_", string.Empty, StringComparison.Ordinal)
|
||||
.Replace("-", string.Empty, StringComparison.Ordinal);
|
||||
foreach (var candidate in Enum.GetValues<TEnum>())
|
||||
{
|
||||
if (string.Equals(candidate.ToString(), normalized, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return candidate;
|
||||
}
|
||||
}
|
||||
|
||||
throw new TenantAdminDirectException("Enum value was invalid.", code);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user