forked from xiongyuxing/tiku-backend.net
463 lines
20 KiB
C#
463 lines
20 KiB
C#
using System.Net;
|
|
using System.Net.Http.Json;
|
|
using System.Text.Json;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Tiku.Api.Contracts;
|
|
using Tiku.Domain.Catalog;
|
|
using Tiku.Domain.Common;
|
|
using Tiku.Domain.Identity;
|
|
using Tiku.Domain.Learning;
|
|
using Tiku.Domain.Operations;
|
|
using Tiku.Domain.Tenancy;
|
|
using Tiku.Infrastructure.Auth;
|
|
using Tiku.Infrastructure.Persistence;
|
|
|
|
namespace Tiku.IntegrationTests.Api;
|
|
|
|
public sealed class TenantAdminDirectEndpointTests
|
|
{
|
|
[Fact]
|
|
public async Task Tenant_admin_can_manage_classes_members_and_students()
|
|
{
|
|
await using var factory = new ApiTestFactory();
|
|
var seed = await SeedAdminAsync(factory);
|
|
var regionId = Guid.NewGuid();
|
|
await factory.SeedAsync(new Region { Id = regionId, TenantId = seed.TenantId, Name = "四川" });
|
|
using var client = factory.CreateClient();
|
|
await LoginAsync(client, seed);
|
|
|
|
var classResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/classes",
|
|
new UpsertTenantAdminClassDto
|
|
{
|
|
RegionId = regionId,
|
|
Code = "A001",
|
|
Name = "冲刺一班",
|
|
Order = 1
|
|
});
|
|
var classJson = await ReadJsonAsync(classResponse);
|
|
var classId = classJson.RootElement.GetProperty("item").GetProperty("id").GetGuid();
|
|
|
|
var memberResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/classes/members",
|
|
new UpsertTenantAdminClassMemberDto
|
|
{
|
|
ClassId = classId,
|
|
MemberType = "student",
|
|
User = new TenantAdminUserLookupDto
|
|
{
|
|
Phone = "13900000001",
|
|
Name = "张同学"
|
|
},
|
|
Metadata = JsonSerializer.SerializeToElement(new { source = "test" })
|
|
});
|
|
var memberJson = await ReadJsonAsync(memberResponse);
|
|
var studentUserId = memberJson.RootElement.GetProperty("item").GetProperty("userId").GetGuid();
|
|
|
|
var listResponse = await client.GetAsync($"/api/tenant-admin/students?classId={classId}");
|
|
var listJson = await ReadJsonAsync(listResponse);
|
|
var classesResponse = await client.GetAsync("/api/tenant-admin/classes");
|
|
var classesJson = await ReadJsonAsync(classesResponse);
|
|
|
|
Assert.Equal(HttpStatusCode.OK, classResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, memberResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, listResponse.StatusCode);
|
|
Assert.Equal(studentUserId, listJson.RootElement.GetProperty("items")[0].GetProperty("userId").GetGuid());
|
|
Assert.Equal(1, classesJson.RootElement.GetProperty("items")[0].GetProperty("studentCount").GetInt32());
|
|
|
|
using var scope = factory.Services.CreateScope();
|
|
var dbContext = scope.ServiceProvider.GetRequiredService<TikuDbContext>();
|
|
Assert.True(await dbContext.StudentProfiles.AnyAsync(profile => profile.TenantId == seed.TenantId && profile.UserId == studentUserId));
|
|
Assert.True(await dbContext.TenantMemberships.AnyAsync(member => member.TenantId == seed.TenantId && member.UserId == studentUserId && member.Role == TenantRole.Student));
|
|
Assert.True(await dbContext.AuditLogs.AnyAsync(log => log.TenantId == seed.TenantId && log.Action == "tenant.class_member.upserted"));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Tenant_admin_can_write_student_notes_and_followups()
|
|
{
|
|
await using var factory = new ApiTestFactory();
|
|
var seed = await SeedAdminAsync(factory);
|
|
var studentId = Guid.NewGuid();
|
|
await factory.SeedAsync(
|
|
new User { Id = studentId, Phone = "13900000002", Name = "李同学" },
|
|
new TenantMembership { TenantId = seed.TenantId, UserId = studentId, Role = TenantRole.Student, Status = MembershipStatus.Active },
|
|
new StudentProfile { TenantId = seed.TenantId, UserId = studentId });
|
|
using var client = factory.CreateClient();
|
|
await LoginAsync(client, seed);
|
|
|
|
var noteResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/student-notes",
|
|
new UpsertTenantAdminStudentNoteDto
|
|
{
|
|
StudentUserId = studentId,
|
|
NoteType = "learning",
|
|
Content = "需要关注英语词汇",
|
|
IsPinned = true
|
|
});
|
|
var followupResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/student-followups",
|
|
new UpsertTenantAdminStudentFollowupDto
|
|
{
|
|
StudentUserId = studentId,
|
|
AssignedToUserId = seed.UserId,
|
|
Title = "电话回访",
|
|
FollowupType = "service",
|
|
Priority = "high",
|
|
Status = "in_progress"
|
|
});
|
|
var notesResponse = await client.GetAsync($"/api/tenant-admin/student-notes?studentUserId={studentId}");
|
|
var followupsResponse = await client.GetAsync($"/api/tenant-admin/student-followups?studentUserId={studentId}");
|
|
var notesJson = await ReadJsonAsync(notesResponse);
|
|
var followupsJson = await ReadJsonAsync(followupsResponse);
|
|
|
|
Assert.Equal(HttpStatusCode.OK, noteResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, followupResponse.StatusCode);
|
|
Assert.Single(notesJson.RootElement.GetProperty("items").EnumerateArray());
|
|
Assert.Single(followupsJson.RootElement.GetProperty("items").EnumerateArray());
|
|
Assert.Equal("电话回访", followupsJson.RootElement.GetProperty("items")[0].GetProperty("title").GetString());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Student_status_update_revokes_active_sessions()
|
|
{
|
|
await using var factory = new ApiTestFactory();
|
|
var seed = await SeedAdminAsync(factory);
|
|
var studentId = Guid.NewGuid();
|
|
await factory.SeedAsync(
|
|
new User { Id = studentId, Phone = "13900000003", Name = "王同学" },
|
|
new TenantMembership { TenantId = seed.TenantId, UserId = studentId, Role = TenantRole.Student, Status = MembershipStatus.Active },
|
|
new AuthSession
|
|
{
|
|
TenantId = seed.TenantId,
|
|
UserId = studentId,
|
|
TokenHash = "student-session",
|
|
Provider = "password",
|
|
ExpiresAt = DateTimeOffset.UtcNow.AddHours(1)
|
|
});
|
|
using var client = factory.CreateClient();
|
|
await LoginAsync(client, seed);
|
|
|
|
var statusResponse = await client.PostAsJsonAsync(
|
|
"/api/tenant-admin/students/status",
|
|
new UpdateTenantAdminStudentStatusDto
|
|
{
|
|
UserId = studentId,
|
|
Status = "disabled",
|
|
Reason = "测试禁用"
|
|
});
|
|
|
|
Assert.Equal(HttpStatusCode.OK, statusResponse.StatusCode);
|
|
using var scope = factory.Services.CreateScope();
|
|
var dbContext = scope.ServiceProvider.GetRequiredService<TikuDbContext>();
|
|
Assert.True(await dbContext.AuthSessions.AnyAsync(session => session.UserId == studentId && session.RevokedAt != null));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Tenant_operator_cannot_access_tenant_admin_direct_endpoints()
|
|
{
|
|
await using var factory = new ApiTestFactory();
|
|
var seed = await SeedAdminAsync(factory, TenantRole.TenantOperator);
|
|
using var client = factory.CreateClient();
|
|
await LoginAsync(client, seed);
|
|
|
|
using var response = await client.GetAsync("/api/tenant-admin/students");
|
|
|
|
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Tenant_admin_can_manage_branding_settings_theme_domains_and_auth_providers()
|
|
{
|
|
await using var factory = new ApiTestFactory();
|
|
var seed = await SeedAdminAsync(factory);
|
|
await factory.SeedAsync(new TenantThemeTemplate
|
|
{
|
|
Code = "classic",
|
|
Name = "经典主题",
|
|
Theme = JsonSerializer.SerializeToElement(new { color = "blue" }),
|
|
PublicAssets = JsonSerializer.SerializeToElement(new { logo = "/logo.png" }),
|
|
Status = TenantThemeTemplateStatus.Active
|
|
});
|
|
using var client = factory.CreateClient();
|
|
await LoginAsync(client, seed);
|
|
|
|
var brandingResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/branding",
|
|
new UpsertTenantBrandingDto
|
|
{
|
|
BrandName = "机构题库",
|
|
ShortName = "题库",
|
|
ServiceWechat = "wechat"
|
|
});
|
|
var settingsResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/settings",
|
|
new UpsertTenantSettingsDto
|
|
{
|
|
FeatureFlags = JsonSerializer.SerializeToElement(new { catalog = true }),
|
|
PublicConfig = JsonSerializer.SerializeToElement(new { icp = "蜀ICP备" })
|
|
});
|
|
var previewResponse = await client.PostAsJsonAsync(
|
|
"/api/tenant-admin/theme/preview",
|
|
new PreviewTenantThemeDto
|
|
{
|
|
TemplateCode = "classic",
|
|
Theme = JsonSerializer.SerializeToElement(new { color = "red" })
|
|
});
|
|
var publishResponse = await client.PostAsJsonAsync(
|
|
"/api/tenant-admin/theme/publish",
|
|
new PublishTenantThemeDto { UseDraft = true });
|
|
var domainResponse = await client.PostAsJsonAsync(
|
|
"/api/tenant-admin/domains",
|
|
new CreateTenantDomainDto
|
|
{
|
|
Host = "learn.example.com",
|
|
DomainType = "custom",
|
|
IsPrimary = true
|
|
});
|
|
var authProviderResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/auth-providers",
|
|
new UpsertTenantAuthProviderDto
|
|
{
|
|
Provider = "wechat_mp",
|
|
Status = "active",
|
|
DisplayName = "微信公众号",
|
|
ConfigPublic = JsonSerializer.SerializeToElement(new { appId = "wx-test" })
|
|
});
|
|
var secretSettingsResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/settings",
|
|
new UpsertTenantSettingsDto
|
|
{
|
|
PublicConfig = JsonSerializer.SerializeToElement(new { appSecret = "nope" })
|
|
});
|
|
|
|
Assert.Equal(HttpStatusCode.OK, brandingResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, settingsResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, previewResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, publishResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, domainResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, authProviderResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.BadRequest, secretSettingsResponse.StatusCode);
|
|
|
|
using var scope = factory.Services.CreateScope();
|
|
var dbContext = scope.ServiceProvider.GetRequiredService<TikuDbContext>();
|
|
Assert.True(await dbContext.TenantBrandings.AnyAsync(item => item.TenantId == seed.TenantId && item.BrandName == "机构题库"));
|
|
Assert.True(await dbContext.TenantThemeConfigs.AnyAsync(item => item.TenantId == seed.TenantId && item.ActiveTemplateCode == "classic"));
|
|
Assert.True(await dbContext.TenantDomains.AnyAsync(item => item.TenantId == seed.TenantId && item.Host == "learn.example.com" && item.IsPrimary));
|
|
Assert.True(await dbContext.TenantAuthProviders.AnyAsync(item => item.TenantId == seed.TenantId && item.Provider == "wechat_mp"));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Tenant_admin_can_manage_role_templates_members_and_audit_logs()
|
|
{
|
|
await using var factory = new ApiTestFactory();
|
|
var seed = await SeedAdminAsync(factory);
|
|
using var client = factory.CreateClient();
|
|
await LoginAsync(client, seed);
|
|
|
|
var roleResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/role-templates",
|
|
new UpsertTenantAdminRoleTemplateDto
|
|
{
|
|
Code = "teacher-basic",
|
|
Name = "教师基础权限",
|
|
BaseRole = "teacher",
|
|
Permissions = JsonSerializer.SerializeToElement(new Dictionary<string, bool>
|
|
{
|
|
["classes:read"] = true,
|
|
["students:read"] = true
|
|
}),
|
|
FieldPermissions = JsonSerializer.SerializeToElement(new Dictionary<string, bool>
|
|
{
|
|
["student.phone"] = false
|
|
})
|
|
});
|
|
var roleJson = await ReadJsonAsync(roleResponse);
|
|
var roleTemplateId = roleJson.RootElement.GetProperty("item").GetProperty("id").GetGuid();
|
|
|
|
var memberResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/members",
|
|
new UpsertTenantAdminMemberDto
|
|
{
|
|
RoleTemplateId = roleTemplateId,
|
|
User = new TenantAdminUserLookupDto
|
|
{
|
|
Phone = "13900000004",
|
|
Name = "教师"
|
|
}
|
|
});
|
|
var membersResponse = await client.GetAsync("/api/tenant-admin/members?role=teacher");
|
|
var permissionsResponse = await client.GetAsync("/api/tenant-admin/permissions");
|
|
var auditResponse = await client.GetAsync("/api/tenant-admin/audit-logs?action=tenant.role_template");
|
|
var membersJson = await ReadJsonAsync(membersResponse);
|
|
var auditJson = await ReadJsonAsync(auditResponse);
|
|
|
|
Assert.Equal(HttpStatusCode.OK, roleResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, memberResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, membersResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, permissionsResponse.StatusCode);
|
|
Assert.Single(membersJson.RootElement.GetProperty("items").EnumerateArray());
|
|
Assert.NotEmpty(auditJson.RootElement.GetProperty("items").EnumerateArray());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Tenant_admin_can_manage_badges_notifications_and_feedbacks()
|
|
{
|
|
await using var factory = new ApiTestFactory();
|
|
var seed = await SeedAdminAsync(factory);
|
|
var studentId = Guid.NewGuid();
|
|
var feedbackId = Guid.NewGuid();
|
|
await factory.SeedAsync(
|
|
new User { Id = studentId, Phone = "13900000005", Name = "反馈学生" },
|
|
new TenantMembership { TenantId = seed.TenantId, UserId = studentId, Role = TenantRole.Student, Status = MembershipStatus.Active },
|
|
new StudentProfile { TenantId = seed.TenantId, UserId = studentId },
|
|
new Report
|
|
{
|
|
Id = feedbackId,
|
|
TenantId = seed.TenantId,
|
|
UserId = studentId,
|
|
Type = ReportType.Suggestion,
|
|
Title = "希望增加解析",
|
|
Description = "视频解析再详细一点",
|
|
Status = ReportStatus.Pending
|
|
});
|
|
using var client = factory.CreateClient();
|
|
await LoginAsync(client, seed);
|
|
|
|
var badgeResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/badges",
|
|
new UpsertTenantAdminBadgeDto
|
|
{
|
|
Name = "反馈达人",
|
|
Category = "feedback",
|
|
UnlockType = "manual",
|
|
Order = 1
|
|
});
|
|
var badgeJson = await ReadJsonAsync(badgeResponse);
|
|
var badgeId = badgeJson.RootElement.GetProperty("item").GetProperty("id").GetGuid();
|
|
|
|
var grantResponse = await client.PostAsJsonAsync(
|
|
"/api/tenant-admin/badge-grants",
|
|
new GrantTenantAdminBadgeDto
|
|
{
|
|
UserId = studentId,
|
|
BadgeId = badgeId,
|
|
Note = "感谢反馈"
|
|
});
|
|
var notificationResponse = await client.PutAsJsonAsync(
|
|
"/api/tenant-admin/notifications",
|
|
new UpsertTenantAdminNotificationDto
|
|
{
|
|
UserId = studentId,
|
|
NotificationType = "admin_message",
|
|
Severity = "info",
|
|
Title = "学习提醒",
|
|
Message = "记得复习错题",
|
|
DedupeKey = "daily-review"
|
|
});
|
|
var notificationsListResponse = await client.GetAsync($"/api/tenant-admin/notifications?userId={studentId}");
|
|
var feedbackUpdateResponse = await client.PostAsJsonAsync(
|
|
"/api/tenant-admin/feedbacks/status",
|
|
new UpdateTenantAdminFeedbackDto
|
|
{
|
|
FeedbackId = feedbackId,
|
|
Status = "resolved",
|
|
Priority = "high",
|
|
Resolution = "已安排补充解析",
|
|
Note = "后台处理完成"
|
|
});
|
|
var feedbackListResponse = await client.GetAsync("/api/tenant-admin/feedbacks?status=resolved");
|
|
var notificationsJson = await ReadJsonAsync(notificationsListResponse);
|
|
var feedbackJson = await ReadJsonAsync(feedbackListResponse);
|
|
|
|
Assert.Equal(HttpStatusCode.OK, badgeResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, grantResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, notificationResponse.StatusCode);
|
|
Assert.Equal(HttpStatusCode.OK, feedbackUpdateResponse.StatusCode);
|
|
Assert.True(notificationsJson.RootElement.GetProperty("items").GetArrayLength() >= 2);
|
|
Assert.Single(feedbackJson.RootElement.GetProperty("items").EnumerateArray());
|
|
|
|
using var scope = factory.Services.CreateScope();
|
|
var dbContext = scope.ServiceProvider.GetRequiredService<TikuDbContext>();
|
|
Assert.True(await dbContext.UserBadges.AnyAsync(item => item.TenantId == seed.TenantId && item.UserId == studentId && item.BadgeId == badgeId));
|
|
Assert.True(await dbContext.UserNotifications.AnyAsync(item => item.TenantId == seed.TenantId && item.UserId == studentId && item.NotificationType == "badge_granted"));
|
|
Assert.True(await dbContext.ReportStatusEvents.AnyAsync(item => item.TenantId == seed.TenantId && item.ReportId == feedbackId && item.ToStatus == ReportStatus.Resolved));
|
|
}
|
|
|
|
private static async Task<(Guid TenantId, Guid UserId, string Phone)> SeedAdminAsync(
|
|
ApiTestFactory factory,
|
|
TenantRole role = TenantRole.TenantAdmin)
|
|
{
|
|
var tenantId = Guid.NewGuid();
|
|
var userId = Guid.NewGuid();
|
|
var phone = $"137{Random.Shared.Next(10000000, 99999999)}";
|
|
var passwordHash = new PasswordHasher().Hash("passw0rd!");
|
|
|
|
await factory.SeedAsync(
|
|
new Tenant
|
|
{
|
|
Id = tenantId,
|
|
Slug = tenantId.ToString("N"),
|
|
Name = "Test Tenant",
|
|
Status = TenantStatus.Active,
|
|
Metadata = JsonDefaults.Object()
|
|
},
|
|
new User
|
|
{
|
|
Id = userId,
|
|
Phone = phone,
|
|
Name = "Tenant Admin"
|
|
},
|
|
new TenantMembership
|
|
{
|
|
TenantId = tenantId,
|
|
UserId = userId,
|
|
Role = role,
|
|
Status = MembershipStatus.Active
|
|
},
|
|
new UserIdentity
|
|
{
|
|
UserId = userId,
|
|
Provider = "password",
|
|
ProviderSubject = phone,
|
|
Phone = phone,
|
|
SecretPayload = CreateSecretPayload(passwordHash)
|
|
});
|
|
|
|
return (tenantId, userId, phone);
|
|
}
|
|
|
|
private static async Task LoginAsync(
|
|
HttpClient client,
|
|
(Guid TenantId, Guid UserId, string Phone) seed)
|
|
{
|
|
var loginResponse = await client.PostAsJsonAsync(
|
|
"/api/auth/login/password",
|
|
new PasswordLoginDto
|
|
{
|
|
TenantId = seed.TenantId,
|
|
Phone = seed.Phone,
|
|
Password = "passw0rd!"
|
|
});
|
|
var loginJson = await ReadJsonAsync(loginResponse);
|
|
var accessToken = loginJson.RootElement
|
|
.GetProperty("tokens")
|
|
.GetProperty("accessToken")
|
|
.GetString();
|
|
client.DefaultRequestHeaders.Authorization = new("Bearer", accessToken);
|
|
}
|
|
|
|
private static async Task<JsonDocument> ReadJsonAsync(HttpResponseMessage response)
|
|
{
|
|
var stream = await response.Content.ReadAsStreamAsync();
|
|
return await JsonDocument.ParseAsync(stream);
|
|
}
|
|
|
|
private static JsonElement CreateSecretPayload(string passwordHash)
|
|
{
|
|
using var document = JsonDocument.Parse(
|
|
$$"""{"passwordHash":{{JsonSerializer.Serialize(passwordHash)}}}""");
|
|
return document.RootElement.Clone();
|
|
}
|
|
}
|