From 3f7150cb5c936d06dc17f2c252f8c90ba0f50aad Mon Sep 17 00:00:00 2001 From: wizardchen Date: Wed, 13 May 2026 22:23:59 +0800 Subject: [PATCH] feat(rbac): tenant member management + invite_only gate (PR 3 of 3, #1303) Wire the human-facing surface for the tenant-RBAC system that PR 1 introduced and PR 2 enforced: REST endpoints + UI for managing tenant members, plus the long-pending invite_only registration gate. Backend - internal/handler/auth.go: Register now rejects with 403 when auth.registration_mode=invite_only. PR 1 already exposes the mode via /auth/config so the frontend hides the sign-up link; this is the server-side enforcement for direct API calls. - internal/handler/tenant_member.go: new TenantMemberHandler with ListMembers / AddMember / UpdateMemberRole / RemoveMember. Maps service-layer sentinels onto HTTP semantics (ErrLastOwner -> 409, ErrMembershipAlreadyExists -> 409, ErrUserNotFound on AddMember -> 404, ErrInvalidTenantRole -> 400). AddMember requires the invitee to already have an account; SMTP-driven email invites are deferred. - internal/types/tenant_member.go: new TenantMemberResponse projection carrying the fields the management UI renders (email, username, avatar, role, joined_at). - internal/router/router.go: four routes under /tenants/:id/members gated per the matrix (Viewer+ for list, Owner+ for every mutation). - internal/container/container.go: dig provider for the new handler. Tests - handler/tenant_member_test.go: 12 table-driven cases covering happy path, dangling-user tolerance, ErrLastOwner -> 409, ErrMembershipNotFound -> 404, ErrMembershipAlreadyExists -> 409, unknown email -> 404, invalid role rejected before user lookup, bad tenant id -> 400. - handler/auth_register_invite_only_test.go: invite_only -> 403, self_serve -> 201, nil Auth config falls through. Frontend - src/api/tenant/members.ts: typed client (TenantRole/TenantMember/...) for the four endpoints. - src/views/settings/TenantMembers.vue: members table with add dialog, inline role select, confirm-remove modal. All mutation widgets gated behind currentTenantRole === 'owner'; server still enforces. - src/views/settings/Settings.vue: register the Members tab; show only when currentTenantRole is loaded (avoids tab flash on cold nav). - i18n in en-US/zh-CN/ko-KR/ru-RU: new tenantMember namespace covering all UI strings and structured error messages (lastOwner / userNotFound / alreadyMember / invalidRole etc). This completes the #1303 RBAC rollout. With cfg.Tenant.EnableRBAC=true operators now have a full management surface; with EnableRBAC=false the routes still exist but mutations log-and-pass per PR 2 contract. --- frontend/src/api/tenant/members.ts | 95 +++++ frontend/src/i18n/locales/en-US.ts | 49 +++ frontend/src/i18n/locales/ko-KR.ts | 49 +++ frontend/src/i18n/locales/ru-RU.ts | 49 +++ frontend/src/i18n/locales/zh-CN.ts | 49 +++ frontend/src/views/settings/Settings.vue | 58 ++- frontend/src/views/settings/TenantMembers.vue | 374 ++++++++++++++++++ internal/container/container.go | 1 + internal/handler/auth.go | 10 + .../handler/auth_register_invite_only_test.go | 144 +++++++ internal/handler/tenant_member.go | 312 +++++++++++++++ internal/handler/tenant_member_test.go | 357 +++++++++++++++++ internal/router/router.go | 24 +- internal/types/tenant_member.go | 16 + 14 files changed, 1570 insertions(+), 17 deletions(-) create mode 100644 frontend/src/api/tenant/members.ts create mode 100644 frontend/src/views/settings/TenantMembers.vue create mode 100644 internal/handler/auth_register_invite_only_test.go create mode 100644 internal/handler/tenant_member.go create mode 100644 internal/handler/tenant_member_test.go diff --git a/frontend/src/api/tenant/members.ts b/frontend/src/api/tenant/members.ts new file mode 100644 index 00000000..f2976578 --- /dev/null +++ b/frontend/src/api/tenant/members.ts @@ -0,0 +1,95 @@ +import { get, post, put, del } from '@/utils/request' + +// TenantRole mirrors internal/types/tenant_member.go's four-role enum. +// Keep the string values aligned with the Go constants. +export type TenantRole = 'owner' | 'admin' | 'contributor' | 'viewer' + +export type TenantMemberStatus = 'active' | 'invited' | 'suspended' + +// TenantMember is the API projection of a (user, tenant) membership row, +// already joined with the user's email/username/avatar by the backend. +export interface TenantMember { + user_id: string + email: string + username: string + avatar?: string + role: TenantRole + status: TenantMemberStatus + invited_by?: string | null + joined_at: string +} + +export interface ListMembersResponse { + success: boolean + data?: { + members: TenantMember[] + total: number + } + message?: string +} + +export interface AddMemberRequest { + email: string + role: TenantRole +} + +export interface AddMemberResponse { + success: boolean + data?: TenantMember + message?: string +} + +export interface SimpleResponse { + success: boolean + message?: string +} + +/** + * List all active members of the given tenant. + * Backend: GET /api/v1/tenants/:id/members (Viewer+). + */ +export async function listMembers(tenantId: number): Promise { + return (await get(`/api/v1/tenants/${tenantId}/members`)) as unknown as ListMembersResponse +} + +/** + * Invite an existing user (by email) to the tenant with the given role. + * Backend: POST /api/v1/tenants/:id/members (Owner+). + * + * Returns 404 when the email does not match any registered user — the + * caller should ask the invitee to register first. PR 3 does not yet + * support email-based invites for users who don't have an account. + */ +export async function addMember( + tenantId: number, + body: AddMemberRequest, +): Promise { + return (await post(`/api/v1/tenants/${tenantId}/members`, body)) as unknown as AddMemberResponse +} + +/** + * Change an existing member's role. + * Backend: PUT /api/v1/tenants/:id/members/:user_id (Owner+). + * + * Returns 409 when this would demote the last active Owner of the tenant. + */ +export async function updateMemberRole( + tenantId: number, + userId: string, + role: TenantRole, +): Promise { + return (await put(`/api/v1/tenants/${tenantId}/members/${userId}`, { role })) as unknown as SimpleResponse +} + +/** + * Remove a member from the tenant. + * Backend: DELETE /api/v1/tenants/:id/members/:user_id (Owner+). + * + * Returns 409 when this would remove the last active Owner. + */ +export async function removeMember( + tenantId: number, + userId: string, +): Promise { + return (await del(`/api/v1/tenants/${tenantId}/members/${userId}`)) as unknown as SimpleResponse +} diff --git a/frontend/src/i18n/locales/en-US.ts b/frontend/src/i18n/locales/en-US.ts index 95304d6a..88c4e284 100755 --- a/frontend/src/i18n/locales/en-US.ts +++ b/frontend/src/i18n/locales/en-US.ts @@ -4303,4 +4303,53 @@ export default { confirmRemoveBody: 'This permanently deletes the stored credential. Integrations using it will stop working until you configure a new value.', }, + tenantMember: { + title: 'Members', + sectionDescription: 'Invite teammates to the tenant and manage their roles. Only Owner can add or remove members.', + totalCount: '{n} members', + loading: 'Loading members…', + retry: 'Retry', + columns: { + username: 'Name', + email: 'Email', + role: 'Role', + joinedAt: 'Joined', + }, + role: { + owner: 'Owner', + admin: 'Admin', + contributor: 'Contributor', + viewer: 'Viewer', + }, + add: { + button: 'Add Member', + dialogTitle: 'Invite Member', + emailLabel: 'Email', + emailPlaceholder: 'invitee@example.com', + roleLabel: 'Role', + submit: 'Invite', + success: 'Member added', + }, + remove: { + button: 'Remove', + confirmTitle: 'Remove member?', + confirmBody: 'Are you sure you want to remove {name} from this tenant? They will lose access immediately.', + confirm: 'Remove', + success: 'Member removed', + }, + roleChange: { + success: 'Role updated', + }, + errors: { + emailRequired: 'Email is required', + emailFormat: 'Invalid email address', + roleRequired: 'Role is required', + userNotFound: 'No registered user with this email. Ask them to sign up first.', + alreadyMember: 'This user is already a member of the tenant.', + lastOwner: 'Cannot demote or remove the last Owner. Promote another member to Owner first.', + notFound: 'Membership not found.', + noTenant: 'No active tenant.', + generic: 'Something went wrong. Please try again.', + }, + }, } diff --git a/frontend/src/i18n/locales/ko-KR.ts b/frontend/src/i18n/locales/ko-KR.ts index 2e4fd649..05dc2850 100755 --- a/frontend/src/i18n/locales/ko-KR.ts +++ b/frontend/src/i18n/locales/ko-KR.ts @@ -4363,4 +4363,53 @@ export default { confirmRemoveBody: "저장된 credential이 영구적으로 삭제되며, 이를 사용하는 통합은 새 값을 구성할 때까지 동작하지 않습니다.", }, + tenantMember: { + title: "멤버 관리", + sectionDescription: "테넌트에 동료를 초대하고 역할을 관리합니다. 소유자만 멤버를 추가하거나 제거할 수 있습니다.", + totalCount: "총 {n}명", + loading: "멤버를 불러오는 중…", + retry: "다시 시도", + columns: { + username: "이름", + email: "이메일", + role: "역할", + joinedAt: "가입일", + }, + role: { + owner: "소유자", + admin: "관리자", + contributor: "기여자", + viewer: "뷰어", + }, + add: { + button: "멤버 초대", + dialogTitle: "멤버 초대", + emailLabel: "이메일", + emailPlaceholder: "invitee@example.com", + roleLabel: "역할", + submit: "초대", + success: "멤버를 추가했습니다", + }, + remove: { + button: "제거", + confirmTitle: "멤버를 제거하시겠어요?", + confirmBody: "{name} 님을 이 테넌트에서 제거하시겠어요? 즉시 접근 권한이 해제됩니다.", + confirm: "제거", + success: "멤버를 제거했습니다", + }, + roleChange: { + success: "역할이 업데이트되었습니다", + }, + errors: { + emailRequired: "이메일을 입력하세요", + emailFormat: "올바른 이메일 형식이 아닙니다", + roleRequired: "역할을 선택하세요", + userNotFound: "해당 이메일로 가입된 사용자가 없습니다. 먼저 가입을 요청하세요.", + alreadyMember: "이미 이 테넌트의 멤버입니다.", + lastOwner: "마지막 소유자를 강등하거나 제거할 수 없습니다. 다른 멤버를 먼저 소유자로 승격하세요.", + notFound: "멤버를 찾을 수 없습니다.", + noTenant: "활성 테넌트가 없습니다.", + generic: "오류가 발생했습니다. 다시 시도해 주세요.", + }, + }, }; diff --git a/frontend/src/i18n/locales/ru-RU.ts b/frontend/src/i18n/locales/ru-RU.ts index 557368e8..fd43b82b 100755 --- a/frontend/src/i18n/locales/ru-RU.ts +++ b/frontend/src/i18n/locales/ru-RU.ts @@ -4263,4 +4263,53 @@ export default { confirmRemoveBody: 'Сохранённые учётные данные будут безвозвратно удалены. Интеграции, использующие их, перестанут работать до настройки нового значения.', }, + tenantMember: { + title: 'Участники', + sectionDescription: 'Приглашайте коллег в тенант и управляйте их ролями. Добавлять и удалять участников может только Владелец.', + totalCount: 'Участников: {n}', + loading: 'Загрузка участников…', + retry: 'Повторить', + columns: { + username: 'Имя', + email: 'Email', + role: 'Роль', + joinedAt: 'Дата вступления', + }, + role: { + owner: 'Владелец', + admin: 'Администратор', + contributor: 'Участник', + viewer: 'Наблюдатель', + }, + add: { + button: 'Пригласить', + dialogTitle: 'Пригласить участника', + emailLabel: 'Email', + emailPlaceholder: 'invitee@example.com', + roleLabel: 'Роль', + submit: 'Пригласить', + success: 'Участник добавлен', + }, + remove: { + button: 'Удалить', + confirmTitle: 'Удалить участника?', + confirmBody: 'Вы уверены, что хотите удалить {name} из этого тенанта? Доступ будет отозван немедленно.', + confirm: 'Удалить', + success: 'Участник удалён', + }, + roleChange: { + success: 'Роль обновлена', + }, + errors: { + emailRequired: 'Укажите email', + emailFormat: 'Неверный формат email', + roleRequired: 'Выберите роль', + userNotFound: 'Пользователь с таким email не зарегистрирован. Попросите его зарегистрироваться.', + alreadyMember: 'Этот пользователь уже участник тенанта.', + lastOwner: 'Нельзя понизить или удалить последнего Владельца. Сначала повысьте кого-то ещё до Владельца.', + notFound: 'Участник не найден.', + noTenant: 'Нет активного тенанта.', + generic: 'Что-то пошло не так. Попробуйте ещё раз.', + }, + }, } diff --git a/frontend/src/i18n/locales/zh-CN.ts b/frontend/src/i18n/locales/zh-CN.ts index 069d98b0..814330d3 100755 --- a/frontend/src/i18n/locales/zh-CN.ts +++ b/frontend/src/i18n/locales/zh-CN.ts @@ -4296,4 +4296,53 @@ export default { confirmRemoveBody: "此操作将永久删除已保存的凭据,依赖它的集成将停止工作,直到您重新配置。", }, + tenantMember: { + title: "成员管理", + sectionDescription: "邀请伙伴加入当前租户并分配角色。只有 Owner 可以新增或移除成员。", + totalCount: "共 {n} 位成员", + loading: "正在加载成员…", + retry: "重试", + columns: { + username: "姓名", + email: "邮箱", + role: "角色", + joinedAt: "加入时间", + }, + role: { + owner: "拥有者", + admin: "管理员", + contributor: "贡献者", + viewer: "查看者", + }, + add: { + button: "邀请成员", + dialogTitle: "邀请成员", + emailLabel: "邮箱", + emailPlaceholder: "invitee@example.com", + roleLabel: "角色", + submit: "邀请", + success: "已添加成员", + }, + remove: { + button: "移除", + confirmTitle: "确认移除?", + confirmBody: "确定要将 {name} 从当前租户中移除吗?该用户会立即失去访问权限。", + confirm: "移除", + success: "已移除成员", + }, + roleChange: { + success: "角色已更新", + }, + errors: { + emailRequired: "请输入邮箱", + emailFormat: "邮箱格式不正确", + roleRequired: "请选择角色", + userNotFound: "该邮箱尚未注册,请先邀请对方注册账号。", + alreadyMember: "该用户已经是当前租户的成员。", + lastOwner: "无法降级或移除最后一位 Owner,请先把其他成员提升为 Owner。", + notFound: "未找到对应的成员。", + noTenant: "当前没有可操作的租户。", + generic: "操作失败,请稍后重试。", + }, + }, }; diff --git a/frontend/src/views/settings/Settings.vue b/frontend/src/views/settings/Settings.vue index d42d786d..5d645b54 100644 --- a/frontend/src/views/settings/Settings.vue +++ b/frontend/src/views/settings/Settings.vue @@ -142,6 +142,11 @@ + +
+ +
+
@@ -164,6 +169,7 @@ import { ref, computed, watch, onMounted, onUnmounted } from 'vue' import { useRoute, useRouter } from 'vue-router' import { useUIStore } from '@/stores/ui' +import { useAuthStore } from '@/stores/auth' import { useI18n } from 'vue-i18n' import SystemInfo from './SystemInfo.vue' import TenantInfo from './TenantInfo.vue' @@ -178,31 +184,53 @@ import VectorStoreSettings from './VectorStoreSettings.vue' import ParserEngineSettings from './ParserEngineSettings.vue' import StorageEngineSettings from './StorageEngineSettings.vue' import WeKnoraCloudSettings from './WeKnoraCloudSettings.vue' +import TenantMembers from './TenantMembers.vue' const route = useRoute() const router = useRouter() const uiStore = useUIStore() +const authStore = useAuthStore() const { t } = useI18n() const currentSection = ref('general') const currentSubSection = ref('') const expandedMenus = ref([]) -const navItems = computed(() => [ - { key: 'general', icon: 'setting', label: t('general.title') }, - { key: 'ollama', icon: 'server', label: 'Ollama' }, - { key: 'weknoracloud', icon: '', label: 'WeKnora Cloud' }, - { key: 'models', icon: 'control-platform', label: t('settings.modelManagement') }, - { key: 'websearch', icon: 'search', label: t('settings.webSearchConfig') }, - { key: 'chathistory', icon: 'chat', label: t('chatHistorySettings.title') }, - { key: 'vectorstore', icon: 'data-base', label: t('settings.vectorStoreEngine') }, - { key: 'parser', icon: 'file-search', label: t('settings.parserEngine') }, - { key: 'storage', icon: 'cloud', label: t('settings.storageEngine') }, - { key: 'mcp', icon: 'tools', label: t('settings.mcpService') }, - { key: 'system', icon: 'info-circle', label: t('settings.systemSettings') }, - { key: 'tenant', icon: 'user-circle', label: t('settings.tenantInfo') }, - { key: 'api', icon: 'secured', label: t('settings.apiInfo') } -]) +const navItems = computed(() => { + // Optional `children` keeps the existing template's submenu plumbing + // happy (it iterates `item.children`); none of the current tabs use + // it, but staying compatible avoids introducing a new typing-only + // diff scattered across the template. + type NavItem = { + key: string + icon: string + label: string + children?: Array<{ key: string; label: string }> + } + const items: NavItem[] = [ + { key: 'general', icon: 'setting', label: t('general.title') }, + { key: 'ollama', icon: 'server', label: 'Ollama' }, + { key: 'weknoracloud', icon: '', label: 'WeKnora Cloud' }, + { key: 'models', icon: 'control-platform', label: t('settings.modelManagement') }, + { key: 'websearch', icon: 'search', label: t('settings.webSearchConfig') }, + { key: 'chathistory', icon: 'chat', label: t('chatHistorySettings.title') }, + { key: 'vectorstore', icon: 'data-base', label: t('settings.vectorStoreEngine') }, + { key: 'parser', icon: 'file-search', label: t('settings.parserEngine') }, + { key: 'storage', icon: 'cloud', label: t('settings.storageEngine') }, + { key: 'mcp', icon: 'tools', label: t('settings.mcpService') }, + { key: 'system', icon: 'info-circle', label: t('settings.systemSettings') }, + { key: 'tenant', icon: 'user-circle', label: t('settings.tenantInfo') }, + ] + // Member management is hidden until the auth middleware resolves a + // real tenant role for the user. Empty string means "membership not + // loaded yet" — better to suppress the tab than to flash it on cold + // navigation. Server still enforces every mutation. + if (authStore.currentTenantRole) { + items.push({ key: 'members', icon: 'usergroup', label: t('tenantMember.title') }) + } + items.push({ key: 'api', icon: 'secured', label: t('settings.apiInfo') }) + return items +}) // 导航项点击处理 const handleNavClick = (item: any) => { diff --git a/frontend/src/views/settings/TenantMembers.vue b/frontend/src/views/settings/TenantMembers.vue new file mode 100644 index 00000000..68a15753 --- /dev/null +++ b/frontend/src/views/settings/TenantMembers.vue @@ -0,0 +1,374 @@ + + + + + diff --git a/internal/container/container.go b/internal/container/container.go index 05f68d7d..d788035b 100644 --- a/internal/container/container.go +++ b/internal/container/container.go @@ -282,6 +282,7 @@ func BuildContainer(container *dig.Container) *dig.Container { // HTTP handlers layer logger.Debugf(ctx, "[Container] Registering HTTP handlers...") must(container.Provide(handler.NewTenantHandler)) + must(container.Provide(handler.NewTenantMemberHandler)) must(container.Provide(handler.NewKnowledgeBaseHandler)) must(container.Provide(handler.NewKnowledgeHandler)) must(container.Provide(handler.NewChunkHandler)) diff --git a/internal/handler/auth.go b/internal/handler/auth.go index fda34d9c..821fa61f 100644 --- a/internal/handler/auth.go +++ b/internal/handler/auth.go @@ -67,6 +67,16 @@ func (h *AuthHandler) Register(c *gin.Context) { return } + // 当 auth.registration_mode=invite_only 时,public 注册被关闭。 + // 新成员只能由 Owner 通过 /tenants/:id/members 添加(PR 3 of #1303)。 + // 前端在 PR 1 已经会读 /auth/config 隐藏注册入口;这里是直接 API 调用的兜底。 + if h.configInfo != nil && h.configInfo.Auth != nil && h.configInfo.Auth.IsInviteOnly() { + logger.Warn(ctx, "Registration rejected: auth.registration_mode=invite_only") + appErr := errors.NewForbiddenError("Registration is invite-only") + c.Error(appErr) + return + } + var req types.RegisterRequest if err := c.ShouldBindJSON(&req); err != nil { logger.Error(ctx, "Failed to parse registration request parameters", err) diff --git a/internal/handler/auth_register_invite_only_test.go b/internal/handler/auth_register_invite_only_test.go new file mode 100644 index 00000000..a1823797 --- /dev/null +++ b/internal/handler/auth_register_invite_only_test.go @@ -0,0 +1,144 @@ +package handler + +import ( + "bytes" + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "github.com/Tencent/WeKnora/internal/config" + apperrors "github.com/Tencent/WeKnora/internal/errors" + "github.com/Tencent/WeKnora/internal/types" + "github.com/Tencent/WeKnora/internal/types/interfaces" + "github.com/gin-gonic/gin" +) + +// stubRegisterUserService is a UserService whose ONLY useful method is +// Register; every other call panics. Using an interface embedding plus a +// targeted override keeps the test focused on the Register handler's +// branching logic without dragging in the entire user service surface. +type stubRegisterUserService struct { + interfaces.UserService + register func(ctx context.Context, req *types.RegisterRequest) (*types.User, error) +} + +func (s *stubRegisterUserService) Register(ctx context.Context, req *types.RegisterRequest) (*types.User, error) { + return s.register(ctx, req) +} + +// errorCapture mirrors gin's default ErrorHandler behaviour for tests: +// when a handler calls c.Error(), we surface it as an HTTP response so the +// recorder reflects the real client-visible status. The production +// middleware does the same thing in middleware/error_handler.go. +func errorCapture() gin.HandlerFunc { + return func(c *gin.Context) { + c.Next() + if len(c.Errors) == 0 { + return + } + err := c.Errors.Last().Err + if appErr, ok := err.(*apperrors.AppError); ok { + c.JSON(appErr.HTTPCode, gin.H{"error": appErr.Message}) + return + } + c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) + } +} + +func newRegisterTestRouter(h *AuthHandler) *gin.Engine { + gin.SetMode(gin.TestMode) + r := gin.New() + r.Use(errorCapture()) + r.POST("/auth/register", h.Register) + return r +} + +func doRegister(t *testing.T, r *gin.Engine, body any) *httptest.ResponseRecorder { + t.Helper() + buf, _ := json.Marshal(body) + req := httptest.NewRequest(http.MethodPost, "/auth/register", bytes.NewReader(buf)) + req.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + r.ServeHTTP(w, req) + return w +} + +// validRegisterBody returns a payload that passes parameter validation, so +// each test is exercising the gate logic and not the body parser. +func validRegisterBody() map[string]string { + return map[string]string{ + "username": "alice", + "email": "alice@example.com", + "password": "supersecret", + } +} + +func TestRegister_InviteOnlyRejects(t *testing.T) { + // PR 3 (#1303): when auth.registration_mode=invite_only, Register + // must respond 403 BEFORE touching the user service. The frontend + // already hides the sign-up link via /auth/config; this is the + // server-side enforcement for direct API hits. + called := false + us := &stubRegisterUserService{ + register: func(context.Context, *types.RegisterRequest) (*types.User, error) { + called = true + return &types.User{ID: "u1"}, nil + }, + } + h := NewAuthHandler(&config.Config{ + Auth: &config.AuthConfig{RegistrationMode: config.AuthRegistrationModeInviteOnly}, + }, us, nil) + + w := doRegister(t, newRegisterTestRouter(h), validRegisterBody()) + if w.Code != http.StatusForbidden { + t.Fatalf("invite_only must return 403, got %d body=%s", w.Code, w.Body.String()) + } + if called { + t.Fatalf("UserService.Register must not be called when invite_only blocks the request") + } +} + +func TestRegister_SelfServeAllowsRegistration(t *testing.T) { + // Default registration_mode keeps PR 1 behaviour intact: the gate + // is dormant and the request reaches the user service. We don't + // exercise the real service here — just confirm the gate let it + // through by observing the stub being invoked. + called := false + us := &stubRegisterUserService{ + register: func(_ context.Context, _ *types.RegisterRequest) (*types.User, error) { + called = true + return &types.User{ID: "u1", Email: "alice@example.com"}, nil + }, + } + h := NewAuthHandler(&config.Config{ + Auth: &config.AuthConfig{RegistrationMode: config.AuthRegistrationModeSelfServe}, + }, us, nil) + + w := doRegister(t, newRegisterTestRouter(h), validRegisterBody()) + if w.Code != http.StatusCreated { + t.Fatalf("self_serve must allow registration, got %d body=%s", w.Code, w.Body.String()) + } + if !called { + t.Fatalf("UserService.Register should have been invoked") + } +} + +func TestRegister_NilAuthConfigDoesNotPanic(t *testing.T) { + // Defensive: a nil Auth section means the operator hasn't set the + // registration mode at all, which must not crash and must keep the + // legacy "registration enabled" behaviour. Mirrors the nil guard in + // the handler so a config-loading bug doesn't take the server down. + us := &stubRegisterUserService{ + register: func(_ context.Context, _ *types.RegisterRequest) (*types.User, error) { + return &types.User{ID: "u1", Email: "alice@example.com"}, nil + }, + } + h := NewAuthHandler(&config.Config{}, us, nil) + + w := doRegister(t, newRegisterTestRouter(h), validRegisterBody()) + if w.Code != http.StatusCreated { + t.Fatalf("nil Auth config must fall back to allow, got %d body=%s", w.Code, w.Body.String()) + } +} diff --git a/internal/handler/tenant_member.go b/internal/handler/tenant_member.go new file mode 100644 index 00000000..20e25a90 --- /dev/null +++ b/internal/handler/tenant_member.go @@ -0,0 +1,312 @@ +package handler + +import ( + "errors" + "net/http" + "strconv" + "strings" + + "github.com/gin-gonic/gin" + + apprepo "github.com/Tencent/WeKnora/internal/application/repository" + "github.com/Tencent/WeKnora/internal/application/service" + apperrors "github.com/Tencent/WeKnora/internal/errors" + "github.com/Tencent/WeKnora/internal/logger" + "github.com/Tencent/WeKnora/internal/types" + "github.com/Tencent/WeKnora/internal/types/interfaces" + secutils "github.com/Tencent/WeKnora/internal/utils" +) + +// TenantMemberHandler exposes /tenants/:id/members CRUD. The route layer +// enforces RBAC (Viewer for list, Owner for any mutation) — see +// router.RegisterTenantRoutes — so we don't re-check role here. +// +// Tenant scoping: we trust :id == active-tenant because the auth +// middleware has already verified the caller is a member of that tenant. +// Operations on a foreign tenant via :id would have been rejected upstream +// when the user has no membership row in it. +type TenantMemberHandler struct { + memberService interfaces.TenantMemberService + userService interfaces.UserService +} + +// NewTenantMemberHandler wires the dependencies. PR 1 already provides +// both services through the dig container; we just consume them. +func NewTenantMemberHandler( + memberService interfaces.TenantMemberService, + userService interfaces.UserService, +) *TenantMemberHandler { + return &TenantMemberHandler{ + memberService: memberService, + userService: userService, + } +} + +// addMemberRequest is the JSON body for POST /tenants/:id/members. +// Email is the user-facing invite identifier; the handler resolves it to a +// User via UserService.GetUserByEmail. PR 3 does not implement +// email-based invitations for users that don't exist yet — the invitee +// must already have an account. Sending an email invite is tracked as a +// PR 4 candidate. +type addMemberRequest struct { + Email string `json:"email" binding:"required,email"` + Role types.TenantRole `json:"role" binding:"required"` +} + +// updateMemberRoleRequest is the JSON body for PUT /tenants/:id/members/:user_id. +type updateMemberRoleRequest struct { + Role types.TenantRole `json:"role" binding:"required"` +} + +// parseTenantIDFromPath reads :id from the gin route and validates it as +// a tenant ID. Returning (0, false) means we already wrote the error to +// the gin context and the caller should `return` immediately. +func parseTenantIDFromPath(c *gin.Context) (uint64, bool) { + raw := strings.TrimSpace(c.Param("id")) + if raw == "" { + c.Error(apperrors.NewValidationError("tenant id is required")) + return 0, false + } + v, err := strconv.ParseUint(raw, 10, 64) + if err != nil || v == 0 { + c.Error(apperrors.NewValidationError("tenant id must be a positive integer")) + return 0, false + } + return v, true +} + +// ListMembers godoc +// @Summary 列出租户成员 +// @Description 返回当前租户内全部 active 成员(含每位成员的角色、邮箱、头像) +// @Tags 租户成员 +// @Produce json +// @Param id path string true "租户 ID" +// @Success 200 {object} map[string]interface{} +// @Security Bearer +// @Router /tenants/{id}/members [get] +func (h *TenantMemberHandler) ListMembers(c *gin.Context) { + ctx := c.Request.Context() + tenantID, ok := parseTenantIDFromPath(c) + if !ok { + return + } + + members, err := h.memberService.ListByTenant(ctx, tenantID) + if err != nil { + logger.Errorf(ctx, "ListByTenant failed: tenant=%d err=%v", tenantID, err) + c.Error(apperrors.NewInternalServerError("failed to list members").WithDetails(err.Error())) + return + } + + // Hydrate each row with user-facing fields. We do this in the handler + // rather than in the service because it's a pure presentation concern + // — the service stays free of UserService coupling and easier to test. + resp := make([]types.TenantMemberResponse, 0, len(members)) + for _, m := range members { + row := types.TenantMemberResponse{ + UserID: m.UserID, + Role: m.Role, + Status: m.Status, + InvitedBy: m.InvitedBy, + JoinedAt: m.JoinedAt, + } + // User lookup is best-effort: a deleted user account shouldn't + // drop the row from the management UI, otherwise an Owner can + // no longer remove the dangling membership. + if u, err := h.userService.GetUserByID(ctx, m.UserID); err == nil && u != nil { + row.Email = u.Email + row.Username = u.Username + row.Avatar = u.Avatar + } + resp = append(resp, row) + } + + c.JSON(http.StatusOK, gin.H{ + "success": true, + "data": gin.H{ + "members": resp, + "total": len(resp), + }, + }) +} + +// AddMember godoc +// @Summary 添加租户成员 +// @Description Owner 通过 email 邀请已经存在的用户加入当前租户 +// @Tags 租户成员 +// @Accept json +// @Produce json +// @Param id path string true "租户 ID" +// @Param request body addMemberRequest true "邀请请求" +// @Success 201 {object} map[string]interface{} +// @Security Bearer +// @Router /tenants/{id}/members [post] +func (h *TenantMemberHandler) AddMember(c *gin.Context) { + ctx := c.Request.Context() + tenantID, ok := parseTenantIDFromPath(c) + if !ok { + return + } + + var req addMemberRequest + if err := c.ShouldBindJSON(&req); err != nil { + c.Error(apperrors.NewValidationError("invalid request body").WithDetails(err.Error())) + return + } + // Defence in depth — service also re-validates, but rejecting early + // gives the client a better error message than the generic service + // sentinel-mapped 400. + if !req.Role.IsValid() { + c.Error(apperrors.NewValidationError("role must be one of owner/admin/contributor/viewer")) + return + } + + user, err := h.userService.GetUserByEmail(ctx, strings.TrimSpace(req.Email)) + if err != nil { + // ErrUserNotFound is the deliberate "not registered yet" signal; + // mapping it to 404 lets the UI render "ask them to sign up first" + // instead of a generic failure. + if errors.Is(err, apprepo.ErrUserNotFound) { + c.Error(apperrors.NewNotFoundError( + "user with this email is not registered; ask them to sign up first")) + return + } + logger.Errorf(ctx, "GetUserByEmail failed: email=%s err=%v", + secutils.SanitizeForLog(req.Email), err) + c.Error(apperrors.NewInternalServerError("failed to look up user").WithDetails(err.Error())) + return + } + + caller, _ := types.UserIDFromContext(ctx) + var invitedBy *string + if caller != "" { + invitedBy = &caller + } + + member, err := h.memberService.AddMember(ctx, user.ID, tenantID, req.Role, invitedBy) + if err != nil { + switch { + case errors.Is(err, service.ErrInvalidTenantRole): + c.Error(apperrors.NewValidationError(err.Error())) + case errors.Is(err, service.ErrMembershipAlreadyExists): + // 409 reads better than 400 here: the request was syntactically + // fine, the conflict is semantic ("already a member"). + c.Error(apperrors.NewConflictError(err.Error())) + default: + logger.Errorf(ctx, "AddMember failed: user=%s tenant=%d err=%v", + user.ID, tenantID, err) + c.Error(apperrors.NewInternalServerError("failed to add member").WithDetails(err.Error())) + } + return + } + + // Project the freshly added row through the same response shape the + // list endpoint uses, so the UI can swap "Add Member" UX into the + // table without an extra round-trip. + resp := types.TenantMemberResponse{ + UserID: member.UserID, + Email: user.Email, + Username: user.Username, + Avatar: user.Avatar, + Role: member.Role, + Status: member.Status, + InvitedBy: member.InvitedBy, + JoinedAt: member.JoinedAt, + } + c.JSON(http.StatusCreated, gin.H{ + "success": true, + "data": resp, + }) +} + +// UpdateMemberRole godoc +// @Summary 修改租户成员角色 +// @Description Owner 修改某位成员在当前租户内的角色;不能将最后一位 Owner 降级 +// @Tags 租户成员 +// @Accept json +// @Produce json +// @Param id path string true "租户 ID" +// @Param user_id path string true "用户 ID" +// @Param request body updateMemberRoleRequest true "目标角色" +// @Success 200 {object} map[string]interface{} +// @Security Bearer +// @Router /tenants/{id}/members/{user_id} [put] +func (h *TenantMemberHandler) UpdateMemberRole(c *gin.Context) { + ctx := c.Request.Context() + tenantID, ok := parseTenantIDFromPath(c) + if !ok { + return + } + userID := strings.TrimSpace(c.Param("user_id")) + if userID == "" { + c.Error(apperrors.NewValidationError("user_id is required")) + return + } + + var req updateMemberRoleRequest + if err := c.ShouldBindJSON(&req); err != nil { + c.Error(apperrors.NewValidationError("invalid request body").WithDetails(err.Error())) + return + } + if !req.Role.IsValid() { + c.Error(apperrors.NewValidationError("role must be one of owner/admin/contributor/viewer")) + return + } + + if err := h.memberService.UpdateRole(ctx, userID, tenantID, req.Role); err != nil { + switch { + case errors.Is(err, service.ErrMembershipNotFound): + c.Error(apperrors.NewNotFoundError("membership not found")) + case errors.Is(err, service.ErrLastOwner): + c.Error(apperrors.NewConflictError(err.Error())) + case errors.Is(err, service.ErrInvalidTenantRole): + c.Error(apperrors.NewValidationError(err.Error())) + default: + logger.Errorf(ctx, "UpdateRole failed: user=%s tenant=%d err=%v", + userID, tenantID, err) + c.Error(apperrors.NewInternalServerError("failed to update member role").WithDetails(err.Error())) + } + return + } + + c.JSON(http.StatusOK, gin.H{"success": true}) +} + +// RemoveMember godoc +// @Summary 移除租户成员 +// @Description Owner 将某位成员从当前租户中移除(软删除 tenant_members 行);不能移除最后一位 Owner +// @Tags 租户成员 +// @Produce json +// @Param id path string true "租户 ID" +// @Param user_id path string true "用户 ID" +// @Success 200 {object} map[string]interface{} +// @Security Bearer +// @Router /tenants/{id}/members/{user_id} [delete] +func (h *TenantMemberHandler) RemoveMember(c *gin.Context) { + ctx := c.Request.Context() + tenantID, ok := parseTenantIDFromPath(c) + if !ok { + return + } + userID := strings.TrimSpace(c.Param("user_id")) + if userID == "" { + c.Error(apperrors.NewValidationError("user_id is required")) + return + } + + if err := h.memberService.RemoveMember(ctx, userID, tenantID); err != nil { + switch { + case errors.Is(err, service.ErrMembershipNotFound): + c.Error(apperrors.NewNotFoundError("membership not found")) + case errors.Is(err, service.ErrLastOwner): + c.Error(apperrors.NewConflictError(err.Error())) + default: + logger.Errorf(ctx, "RemoveMember failed: user=%s tenant=%d err=%v", + userID, tenantID, err) + c.Error(apperrors.NewInternalServerError("failed to remove member").WithDetails(err.Error())) + } + return + } + + c.JSON(http.StatusOK, gin.H{"success": true}) +} diff --git a/internal/handler/tenant_member_test.go b/internal/handler/tenant_member_test.go new file mode 100644 index 00000000..cebb21f1 --- /dev/null +++ b/internal/handler/tenant_member_test.go @@ -0,0 +1,357 @@ +package handler + +import ( + "bytes" + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + apprepo "github.com/Tencent/WeKnora/internal/application/repository" + "github.com/Tencent/WeKnora/internal/application/service" + "github.com/Tencent/WeKnora/internal/types" + "github.com/Tencent/WeKnora/internal/types/interfaces" + "github.com/gin-gonic/gin" +) + +// stubMemberService is a TenantMemberService whose individual methods can +// be overridden per-test. Embedding the interface keeps the fixture +// minimal — any method not set in a given test will nil-panic if it's +// reached, which is exactly what we want for "the test should not have +// gotten here" assertions. +type stubMemberService struct { + interfaces.TenantMemberService + add func(ctx context.Context, userID string, tenantID uint64, role types.TenantRole, invitedBy *string) (*types.TenantMember, error) + listTenant func(ctx context.Context, tenantID uint64) ([]*types.TenantMember, error) + updateRole func(ctx context.Context, userID string, tenantID uint64, newRole types.TenantRole) error + remove func(ctx context.Context, userID string, tenantID uint64) error +} + +func (s *stubMemberService) AddMember(ctx context.Context, userID string, tenantID uint64, role types.TenantRole, invitedBy *string) (*types.TenantMember, error) { + return s.add(ctx, userID, tenantID, role, invitedBy) +} + +func (s *stubMemberService) ListByTenant(ctx context.Context, tenantID uint64) ([]*types.TenantMember, error) { + return s.listTenant(ctx, tenantID) +} + +func (s *stubMemberService) UpdateRole(ctx context.Context, userID string, tenantID uint64, newRole types.TenantRole) error { + return s.updateRole(ctx, userID, tenantID, newRole) +} + +func (s *stubMemberService) RemoveMember(ctx context.Context, userID string, tenantID uint64) error { + return s.remove(ctx, userID, tenantID) +} + +// stubMemberUserService satisfies just the two UserService methods the +// handler reaches: GetUserByEmail (AddMember translation) and +// GetUserByID (ListMembers hydration). +type stubMemberUserService struct { + interfaces.UserService + getByEmail func(ctx context.Context, email string) (*types.User, error) + getByID func(ctx context.Context, id string) (*types.User, error) +} + +func (s *stubMemberUserService) GetUserByEmail(ctx context.Context, email string) (*types.User, error) { + return s.getByEmail(ctx, email) +} + +func (s *stubMemberUserService) GetUserByID(ctx context.Context, id string) (*types.User, error) { + return s.getByID(ctx, id) +} + +// memberTestRouter wires the handler with the same errorCapture middleware +// production uses, so c.Error() shows up as a real HTTP status in the +// recorder. +func memberTestRouter(h *TenantMemberHandler) *gin.Engine { + gin.SetMode(gin.TestMode) + r := gin.New() + r.Use(errorCapture()) // defined in auth_register_invite_only_test.go + r.GET("/tenants/:id/members", h.ListMembers) + r.POST("/tenants/:id/members", h.AddMember) + r.PUT("/tenants/:id/members/:user_id", h.UpdateMemberRole) + r.DELETE("/tenants/:id/members/:user_id", h.RemoveMember) + return r +} + +// withCallerUser injects the authenticated caller's user ID into the +// request context just like middleware/auth.go does. Several handler +// branches (notably AddMember's invited_by attribution) read this. +func withCallerUser(req *http.Request, callerUserID string) *http.Request { + ctx := context.WithValue(req.Context(), types.UserIDContextKey, callerUserID) + return req.WithContext(ctx) +} + +func doJSON(t *testing.T, r *gin.Engine, method, path string, body any, callerID string) *httptest.ResponseRecorder { + t.Helper() + var reader *bytes.Reader + if body != nil { + buf, _ := json.Marshal(body) + reader = bytes.NewReader(buf) + } else { + reader = bytes.NewReader(nil) + } + req := httptest.NewRequest(method, path, reader) + req.Header.Set("Content-Type", "application/json") + if callerID != "" { + req = withCallerUser(req, callerID) + } + w := httptest.NewRecorder() + r.ServeHTTP(w, req) + return w +} + +// ---------- ListMembers ---------- + +func TestTenantMember_ListMembers_HappyPath(t *testing.T) { + now := time.Now() + ms := &stubMemberService{ + listTenant: func(_ context.Context, tenantID uint64) ([]*types.TenantMember, error) { + if tenantID != 1 { + t.Fatalf("tenantID parsed wrong: got %d", tenantID) + } + return []*types.TenantMember{ + {UserID: "u-owner", TenantID: 1, Role: types.TenantRoleOwner, Status: types.TenantMemberStatusActive, JoinedAt: now}, + {UserID: "u-c", TenantID: 1, Role: types.TenantRoleContributor, Status: types.TenantMemberStatusActive, JoinedAt: now}, + }, nil + }, + } + us := &stubMemberUserService{ + getByID: func(_ context.Context, id string) (*types.User, error) { + return &types.User{ID: id, Username: id, Email: id + "@x.com"}, nil + }, + } + h := NewTenantMemberHandler(ms, us) + + w := doJSON(t, memberTestRouter(h), http.MethodGet, "/tenants/1/members", nil, "u-owner") + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d body=%s", w.Code, w.Body.String()) + } + var resp struct { + Success bool `json:"success"` + Data struct { + Members []types.TenantMemberResponse `json:"members"` + Total int `json:"total"` + } `json:"data"` + } + if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil { + t.Fatalf("decode response: %v", err) + } + if resp.Data.Total != 2 || len(resp.Data.Members) != 2 { + t.Fatalf("expected 2 members, got total=%d len=%d", resp.Data.Total, len(resp.Data.Members)) + } + // Hydration must have populated email so the UI can render avatars. + if resp.Data.Members[0].Email == "" { + t.Fatalf("expected hydrated email, got empty") + } +} + +func TestTenantMember_ListMembers_TolerantToDeletedUsers(t *testing.T) { + // A dangling membership (user account deleted) must still appear in + // the listing so the Owner can clean it up. The service returned the + // row; the user lookup error is silently swallowed. + ms := &stubMemberService{ + listTenant: func(_ context.Context, _ uint64) ([]*types.TenantMember, error) { + return []*types.TenantMember{ + {UserID: "u-ghost", TenantID: 1, Role: types.TenantRoleViewer, Status: types.TenantMemberStatusActive}, + }, nil + }, + } + us := &stubMemberUserService{ + getByID: func(_ context.Context, _ string) (*types.User, error) { + return nil, apprepo.ErrUserNotFound + }, + } + h := NewTenantMemberHandler(ms, us) + + w := doJSON(t, memberTestRouter(h), http.MethodGet, "/tenants/1/members", nil, "u-owner") + if w.Code != http.StatusOK { + t.Fatalf("expected 200 even when user lookup fails, got %d", w.Code) + } + if !strings.Contains(w.Body.String(), `"user_id":"u-ghost"`) { + t.Fatalf("dangling membership must remain in response: %s", w.Body.String()) + } +} + +func TestTenantMember_ListMembers_RejectsBadTenantID(t *testing.T) { + h := NewTenantMemberHandler(&stubMemberService{}, &stubMemberUserService{}) + w := doJSON(t, memberTestRouter(h), http.MethodGet, "/tenants/abc/members", nil, "u1") + if w.Code != http.StatusBadRequest { + t.Fatalf("non-numeric tenant id must 400, got %d", w.Code) + } +} + +// ---------- AddMember ---------- + +func TestTenantMember_AddMember_HappyPath(t *testing.T) { + caller := "u-owner" + now := time.Now() + ms := &stubMemberService{ + add: func(_ context.Context, userID string, tenantID uint64, role types.TenantRole, invitedBy *string) (*types.TenantMember, error) { + if invitedBy == nil || *invitedBy != caller { + t.Fatalf("invited_by must be the caller, got %v", invitedBy) + } + return &types.TenantMember{UserID: userID, TenantID: tenantID, Role: role, Status: types.TenantMemberStatusActive, JoinedAt: now, InvitedBy: invitedBy}, nil + }, + } + us := &stubMemberUserService{ + getByEmail: func(_ context.Context, email string) (*types.User, error) { + return &types.User{ID: "u-bob", Email: email, Username: "bob"}, nil + }, + } + h := NewTenantMemberHandler(ms, us) + + body := map[string]any{"email": "bob@x.com", "role": "contributor"} + w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, caller) + if w.Code != http.StatusCreated { + t.Fatalf("expected 201, got %d body=%s", w.Code, w.Body.String()) + } +} + +func TestTenantMember_AddMember_UnknownEmailReturns404(t *testing.T) { + // PR 3 requires the invitee to already have an account; mapping + // ErrUserNotFound to 404 lets the UI prompt "ask them to sign up + // first" rather than the generic "something failed". + us := &stubMemberUserService{ + getByEmail: func(_ context.Context, _ string) (*types.User, error) { + return nil, apprepo.ErrUserNotFound + }, + } + h := NewTenantMemberHandler(&stubMemberService{}, us) + + body := map[string]any{"email": "ghost@x.com", "role": "viewer"} + w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, "u-owner") + if w.Code != http.StatusNotFound { + t.Fatalf("unknown email must surface as 404, got %d body=%s", w.Code, w.Body.String()) + } +} + +func TestTenantMember_AddMember_DuplicateMaps409(t *testing.T) { + ms := &stubMemberService{ + add: func(_ context.Context, _ string, _ uint64, _ types.TenantRole, _ *string) (*types.TenantMember, error) { + return nil, service.ErrMembershipAlreadyExists + }, + } + us := &stubMemberUserService{ + getByEmail: func(_ context.Context, _ string) (*types.User, error) { + return &types.User{ID: "u-bob", Email: "bob@x.com"}, nil + }, + } + h := NewTenantMemberHandler(ms, us) + + body := map[string]any{"email": "bob@x.com", "role": "contributor"} + w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, "u-owner") + if w.Code != http.StatusConflict { + t.Fatalf("duplicate must surface as 409, got %d", w.Code) + } +} + +func TestTenantMember_AddMember_InvalidRoleRejectedUpfront(t *testing.T) { + // Reject obviously bogus roles before paying for the user lookup. + called := false + us := &stubMemberUserService{ + getByEmail: func(_ context.Context, _ string) (*types.User, error) { + called = true + return &types.User{ID: "u-bob"}, nil + }, + } + h := NewTenantMemberHandler(&stubMemberService{}, us) + + body := map[string]any{"email": "bob@x.com", "role": "wizard"} + w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, "u-owner") + if w.Code != http.StatusBadRequest { + t.Fatalf("invalid role must 400, got %d", w.Code) + } + if called { + t.Fatalf("user lookup must not run for invalid role") + } +} + +// ---------- UpdateMemberRole ---------- + +func TestTenantMember_UpdateRole_HappyPath(t *testing.T) { + ms := &stubMemberService{ + updateRole: func(_ context.Context, userID string, tenantID uint64, newRole types.TenantRole) error { + if userID != "u-bob" || tenantID != 1 || newRole != types.TenantRoleAdmin { + t.Fatalf("unexpected args: user=%s tenant=%d role=%s", userID, tenantID, newRole) + } + return nil + }, + } + h := NewTenantMemberHandler(ms, &stubMemberUserService{}) + + body := map[string]any{"role": "admin"} + w := doJSON(t, memberTestRouter(h), http.MethodPut, "/tenants/1/members/u-bob", body, "u-owner") + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d body=%s", w.Code, w.Body.String()) + } +} + +func TestTenantMember_UpdateRole_LastOwnerMaps409(t *testing.T) { + // Service-layer invariant: the last Owner cannot be demoted. Mapping + // ErrLastOwner to 409 lets the UI render the message inline rather + // than as a generic failure. + ms := &stubMemberService{ + updateRole: func(_ context.Context, _ string, _ uint64, _ types.TenantRole) error { + return service.ErrLastOwner + }, + } + h := NewTenantMemberHandler(ms, &stubMemberUserService{}) + + body := map[string]any{"role": "viewer"} + w := doJSON(t, memberTestRouter(h), http.MethodPut, "/tenants/1/members/u-only-owner", body, "u-only-owner") + if w.Code != http.StatusConflict { + t.Fatalf("last owner demote must 409, got %d", w.Code) + } +} + +func TestTenantMember_UpdateRole_UnknownMembershipMaps404(t *testing.T) { + ms := &stubMemberService{ + updateRole: func(_ context.Context, _ string, _ uint64, _ types.TenantRole) error { + return service.ErrMembershipNotFound + }, + } + h := NewTenantMemberHandler(ms, &stubMemberUserService{}) + + body := map[string]any{"role": "admin"} + w := doJSON(t, memberTestRouter(h), http.MethodPut, "/tenants/1/members/u-ghost", body, "u-owner") + if w.Code != http.StatusNotFound { + t.Fatalf("missing membership must 404, got %d", w.Code) + } +} + +// ---------- RemoveMember ---------- + +func TestTenantMember_RemoveMember_HappyPath(t *testing.T) { + ms := &stubMemberService{ + remove: func(_ context.Context, userID string, tenantID uint64) error { + if userID != "u-bob" || tenantID != 1 { + t.Fatalf("unexpected args: user=%s tenant=%d", userID, tenantID) + } + return nil + }, + } + h := NewTenantMemberHandler(ms, &stubMemberUserService{}) + + w := doJSON(t, memberTestRouter(h), http.MethodDelete, "/tenants/1/members/u-bob", nil, "u-owner") + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d", w.Code) + } +} + +func TestTenantMember_RemoveMember_LastOwnerMaps409(t *testing.T) { + ms := &stubMemberService{ + remove: func(_ context.Context, _ string, _ uint64) error { + return service.ErrLastOwner + }, + } + h := NewTenantMemberHandler(ms, &stubMemberUserService{}) + + w := doJSON(t, memberTestRouter(h), http.MethodDelete, "/tenants/1/members/u-only-owner", nil, "u-only-owner") + if w.Code != http.StatusConflict { + t.Fatalf("last-owner remove must 409, got %d", w.Code) + } +} diff --git a/internal/router/router.go b/internal/router/router.go index e47b5c99..703390f1 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -49,6 +49,7 @@ type RouterParams struct { TenantHandler *handler.TenantHandler TenantService interfaces.TenantService TenantMemberService interfaces.TenantMemberService + TenantMemberHandler *handler.TenantMemberHandler ChunkHandler *handler.ChunkHandler SessionHandler *session.Handler MessageHandler *handler.MessageHandler @@ -149,7 +150,7 @@ func NewRouter(params RouterParams) *gin.Engine { rbacGuards := newRBACGuards(params.Config, params.KBHandler, params.CustomAgentHandler) RegisterAuthRoutes(v1, params.AuthHandler) - RegisterTenantRoutes(v1, params.TenantHandler, rbacGuards) + RegisterTenantRoutes(v1, params.TenantHandler, params.TenantMemberHandler, rbacGuards) RegisterKnowledgeBaseRoutes(v1, params.KBHandler, rbacGuards) RegisterKnowledgeTagRoutes(v1, params.TagHandler, rbacGuards) RegisterKnowledgeRoutes(v1, params.KnowledgeHandler, rbacGuards) @@ -399,12 +400,21 @@ func RegisterChatRoutes(r *gin.RouterGroup, handler *session.Handler, g *rbacGua // - PUT /:id Owner+ (mutate tenant config) // - DELETE /:id Owner+ (also normally a CanAccessAllTenants op) // - POST /:id/api-key Owner+ (rotating the tenant API key is sensitive) +// - GET /:id/members Viewer+ (any member can see who else is in) +// - POST /:id/members Owner+ (only Owner can add new members) +// - PUT /:id/members/:user_id Owner+ (only Owner can change roles) +// - DELETE /:id/members/:user_id Owner+ (only Owner can remove members) // // Cross-tenant superuser endpoints (/tenants/all, /tenants/search, POST // /tenants, GET /tenants, /tenants/kv/*) keep their existing handler-level // CanAccessAllTenants check — they're not gated by tenant role here // because the caller is operating *across* tenants, not within one. -func RegisterTenantRoutes(r *gin.RouterGroup, handler *handler.TenantHandler, g *rbacGuards) { +func RegisterTenantRoutes( + r *gin.RouterGroup, + handler *handler.TenantHandler, + memberHandler *handler.TenantMemberHandler, + g *rbacGuards, +) { // 添加获取所有租户的路由(需要跨租户权限) r.GET("/tenants/all", handler.ListAllTenants) // 添加搜索租户的路由(需要跨租户权限,支持分页和搜索) @@ -423,6 +433,16 @@ func RegisterTenantRoutes(r *gin.RouterGroup, handler *handler.TenantHandler, g // Tenant ID is obtained from authentication context tenantRoutes.GET("/kv/:key", g.Viewer(), handler.GetTenantKV) tenantRoutes.PUT("/kv/:key", g.Admin(), handler.UpdateTenantKV) + + // Tenant member management (PR 3 of #1303). Listing is Viewer+ + // so any active member can see the roster; mutation is Owner+ + // because membership changes are the highest-impact tenant op. + if memberHandler != nil { + tenantRoutes.GET("/:id/members", g.Viewer(), memberHandler.ListMembers) + tenantRoutes.POST("/:id/members", g.Owner(), memberHandler.AddMember) + tenantRoutes.PUT("/:id/members/:user_id", g.Owner(), memberHandler.UpdateMemberRole) + tenantRoutes.DELETE("/:id/members/:user_id", g.Owner(), memberHandler.RemoveMember) + } } } diff --git a/internal/types/tenant_member.go b/internal/types/tenant_member.go index 82a7028d..7562c77b 100644 --- a/internal/types/tenant_member.go +++ b/internal/types/tenant_member.go @@ -119,3 +119,19 @@ type Membership struct { TenantName string `json:"tenant_name"` Role TenantRole `json:"role"` } + +// TenantMemberResponse is the API projection of a TenantMember row joined +// with the human-facing user fields the management UI needs (email, +// username, avatar). It is intentionally NOT the GORM model: returning +// the model directly would leak DeletedAt/UpdatedAt and lock the DB +// schema into the public API. Use this for `/tenants/:id/members` only. +type TenantMemberResponse struct { + UserID string `json:"user_id"` + Email string `json:"email"` + Username string `json:"username"` + Avatar string `json:"avatar,omitempty"` + Role TenantRole `json:"role"` + Status TenantMemberStatus `json:"status"` + InvitedBy *string `json:"invited_by,omitempty"` + JoinedAt time.Time `json:"joined_at"` +}