Files
Enterprise-Knowledge-Base/frontend/src/api/organization/index.ts
T
wizardchen 4158773849 feat: add organization management features
- Introduced a new API for organization management, including creation, updating, and deletion of organizations.
- Implemented organization sharing functionality for knowledge bases, allowing users to share knowledge bases with specific organizations and set permissions.
- Added UI components for organization selection and sharing dialogs.
- Enhanced existing components to support organization-related features, including shared knowledge base handling and organization role management.

This update enhances collaboration capabilities within the application by allowing users to manage and share knowledge bases across different organizations.
2026-02-09 11:40:25 +08:00

492 lines
14 KiB
TypeScript

import { get, post, put, del } from '@/utils/request'
// Organization types
export interface Organization {
id: string
name: string
description: string
avatar?: string
owner_id: string
invite_code?: string
invite_code_expires_at?: string | null
invite_code_validity_days?: number
require_approval?: boolean
member_count?: number
share_count?: number
pending_join_request_count?: number
is_owner?: boolean
my_role?: string
has_pending_upgrade?: boolean
created_at: string
updated_at: string
}
export interface OrganizationMember {
id: string
user_id: string
username: string
email: string
avatar?: string
role: 'admin' | 'editor' | 'viewer'
tenant_id: number
joined_at: string
}
export interface KnowledgeBaseShare {
id: string
knowledge_base_id: string
knowledge_base_name?: string
knowledge_base_type?: string
knowledge_count?: number
chunk_count?: number
organization_id: string
organization_name?: string
shared_by_user_id: string
shared_by_username?: string
source_tenant_id: number
/** Share permission: what the space was granted (viewer/editor) */
permission: 'admin' | 'editor' | 'viewer'
/** Current user's role in this organization (admin/editor/viewer) */
my_role_in_org?: 'admin' | 'editor' | 'viewer'
/** Effective permission for current user = min(permission, my_role_in_org) */
my_permission?: 'admin' | 'editor' | 'viewer'
created_at: string
}
export interface SharedKnowledgeBase {
knowledge_base: {
id: string
name: string
description: string
type: string
knowledge_count?: number
chunk_count?: number
}
share_id: string
organization_id: string
org_name: string
permission: 'admin' | 'editor' | 'viewer'
source_tenant_id: number
shared_at: string
}
export interface OrganizationPreview {
id: string
name: string
description: string
avatar?: string
member_count: number
share_count: number
is_already_member: boolean
require_approval: boolean
created_at: string
}
// Request types
export interface CreateOrganizationRequest {
name: string
description?: string
avatar?: string
invite_code_validity_days?: number // 0=never, 1, 7, 30; default 7
}
export interface UpdateOrganizationRequest {
name?: string
description?: string
avatar?: string
require_approval?: boolean
invite_code_validity_days?: number // 0=never, 1, 7, 30
}
export interface UpdateMemberRoleRequest {
role: 'admin' | 'editor' | 'viewer'
}
export interface JoinOrganizationRequest {
invite_code: string
}
export interface ShareKnowledgeBaseRequest {
organization_id: string
permission: 'admin' | 'editor' | 'viewer'
}
export interface UpdateSharePermissionRequest {
permission: 'admin' | 'editor' | 'viewer'
}
// Response types
export interface ApiResponse<T> {
success: boolean
data?: T
message?: string
}
export interface ListOrganizationsResponse {
organizations: Organization[]
total: number
}
export interface ListMembersResponse {
members: OrganizationMember[]
total: number
}
export interface JoinRequestResponse {
id: string
user_id: string
username: string
email: string
message: string
request_type: 'join' | 'upgrade' // 'join' for new member, 'upgrade' for role upgrade
prev_role?: string // Previous role (only for upgrade requests)
requested_role: string // Role applicant requested: admin, editor, viewer
status: string
created_at: string
reviewed_at?: string
}
export interface ListJoinRequestsResponse {
requests: JoinRequestResponse[]
total: number
}
export interface SubmitJoinRequestRequest {
invite_code: string
message?: string
role?: 'admin' | 'editor' | 'viewer' // Optional: role applicant requests; default viewer
}
export interface ReviewJoinRequestRequest {
approved: boolean
message?: string
role?: 'admin' | 'editor' | 'viewer' // Optional: role to assign when approving; overrides applicant's requested role
}
export interface RequestRoleUpgradeRequest {
requested_role: 'admin' | 'editor' | 'viewer' // The role user wants to upgrade to
message?: string // Optional message explaining the reason
}
export interface InviteMemberRequest {
user_id: string // User ID to invite
role: 'admin' | 'editor' | 'viewer' // Role to assign
}
export interface UserSearchResult {
id: string
username: string
email: string
avatar?: string
}
export interface ListSharesResponse {
shares: KnowledgeBaseShare[]
total: number
}
// Organization API functions
/**
* Create a new organization
*/
export async function createOrganization(req: CreateOrganizationRequest): Promise<ApiResponse<Organization>> {
try {
const response = await post('/api/v1/organizations', req)
return response as unknown as ApiResponse<Organization>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to create organization' }
}
}
/**
* Get organization by ID
*/
export async function getOrganization(id: string): Promise<ApiResponse<Organization>> {
try {
const response = await get(`/api/v1/organizations/${id}`)
return response as unknown as ApiResponse<Organization>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to get organization' }
}
}
/**
* List my organizations
*/
export async function listMyOrganizations(): Promise<ApiResponse<ListOrganizationsResponse>> {
try {
const response = await get('/api/v1/organizations')
return response as unknown as ApiResponse<ListOrganizationsResponse>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to list organizations' }
}
}
/**
* Update organization
*/
export async function updateOrganization(id: string, req: UpdateOrganizationRequest): Promise<ApiResponse<Organization>> {
try {
const response = await put(`/api/v1/organizations/${id}`, req)
return response as unknown as ApiResponse<Organization>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to update organization' }
}
}
/**
* Delete organization
*/
export async function deleteOrganization(id: string): Promise<ApiResponse<void>> {
try {
const response = await del(`/api/v1/organizations/${id}`)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to delete organization' }
}
}
/**
* Join organization by invite code
*/
export async function joinOrganization(req: JoinOrganizationRequest): Promise<ApiResponse<Organization>> {
try {
const response = await post('/api/v1/organizations/join', req)
return response as unknown as ApiResponse<Organization>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to join organization' }
}
}
/**
* Submit a join request (for organizations that require approval).
* Optional role: applicant's requested role (admin/editor/viewer); default viewer.
*/
export async function submitJoinRequest(req: SubmitJoinRequestRequest): Promise<ApiResponse<void>> {
try {
const response = await post('/api/v1/organizations/join-request', req)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to submit join request' }
}
}
/**
* Preview organization by invite code (without joining)
*/
export async function previewOrganization(inviteCode: string): Promise<ApiResponse<OrganizationPreview>> {
try {
const response = await get(`/api/v1/organizations/preview/${inviteCode}`)
return response as unknown as ApiResponse<OrganizationPreview>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to preview organization' }
}
}
/**
* Leave organization
*/
export async function leaveOrganization(id: string): Promise<ApiResponse<void>> {
try {
const response = await post(`/api/v1/organizations/${id}/leave`, {})
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to leave organization' }
}
}
/**
* Request role upgrade in an organization
*/
export async function requestRoleUpgrade(
orgId: string,
request: RequestRoleUpgradeRequest
): Promise<ApiResponse<JoinRequestResponse>> {
try {
const response = await post(`/api/v1/organizations/${orgId}/request-upgrade`, request)
return response as unknown as ApiResponse<JoinRequestResponse>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to submit upgrade request' }
}
}
/**
* Generate new invite code
*/
export async function generateInviteCode(id: string): Promise<ApiResponse<{ invite_code: string }>> {
try {
const response = await post(`/api/v1/organizations/${id}/invite-code`, {})
return response as unknown as ApiResponse<{ invite_code: string }>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to generate invite code' }
}
}
// Member management
/**
* List organization members
*/
export async function listMembers(orgId: string): Promise<ApiResponse<ListMembersResponse>> {
try {
const response = await get(`/api/v1/organizations/${orgId}/members`)
return response as unknown as ApiResponse<ListMembersResponse>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to list members' }
}
}
/**
* Update member role
*/
export async function updateMemberRole(orgId: string, userId: string, req: UpdateMemberRoleRequest): Promise<ApiResponse<void>> {
try {
const response = await put(`/api/v1/organizations/${orgId}/members/${userId}`, req)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to update member role' }
}
}
/**
* Remove member
*/
export async function removeMember(orgId: string, userId: string): Promise<ApiResponse<void>> {
try {
const response = await del(`/api/v1/organizations/${orgId}/members/${userId}`)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to remove member' }
}
}
/**
* List join requests (pending) for an organization (admin only)
*/
export async function listJoinRequests(orgId: string): Promise<ApiResponse<ListJoinRequestsResponse>> {
try {
const response = await get(`/api/v1/organizations/${orgId}/join-requests`)
return response as unknown as ApiResponse<ListJoinRequestsResponse>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to list join requests' }
}
}
/**
* Review join request (approve or reject) - admin only
*/
export async function reviewJoinRequest(orgId: string, requestId: string, req: ReviewJoinRequestRequest): Promise<ApiResponse<void>> {
try {
const response = await put(`/api/v1/organizations/${orgId}/join-requests/${requestId}/review`, req)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to review join request' }
}
}
// Knowledge base sharing
/**
* Share knowledge base to organization
*/
export async function shareKnowledgeBase(kbId: string, req: ShareKnowledgeBaseRequest): Promise<ApiResponse<KnowledgeBaseShare>> {
try {
const response = await post(`/api/v1/knowledge-bases/${kbId}/shares`, req)
return response as unknown as ApiResponse<KnowledgeBaseShare>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to share knowledge base' }
}
}
/**
* List shares for a knowledge base
*/
export async function listKBShares(kbId: string): Promise<ApiResponse<ListSharesResponse>> {
try {
const response = await get(`/api/v1/knowledge-bases/${kbId}/shares`)
return response as unknown as ApiResponse<ListSharesResponse>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to list shares' }
}
}
/**
* Update share permission
*/
export async function updateSharePermission(kbId: string, shareId: string, req: UpdateSharePermissionRequest): Promise<ApiResponse<void>> {
try {
const response = await put(`/api/v1/knowledge-bases/${kbId}/shares/${shareId}`, req)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to update share permission' }
}
}
/**
* Remove share
*/
export async function removeShare(kbId: string, shareId: string): Promise<ApiResponse<void>> {
try {
const response = await del(`/api/v1/knowledge-bases/${kbId}/shares/${shareId}`)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to remove share' }
}
}
/**
* List shared knowledge bases (shared to me through organizations)
*/
export async function listSharedKnowledgeBases(): Promise<ApiResponse<SharedKnowledgeBase[]>> {
try {
const response = await get('/api/v1/shared-knowledge-bases')
return response as unknown as ApiResponse<SharedKnowledgeBase[]>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to list shared knowledge bases' }
}
}
/**
* List knowledge bases shared to a specific organization
*/
export async function listOrgShares(orgId: string): Promise<ApiResponse<ListSharesResponse>> {
try {
const response = await get(`/api/v1/organizations/${orgId}/shares`)
return response as unknown as ApiResponse<ListSharesResponse>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to list organization shares' }
}
}
/**
* Search users for inviting to organization (excludes existing members)
*/
export async function searchUsersForInvite(
orgId: string,
query: string,
limit: number = 10
): Promise<ApiResponse<UserSearchResult[]>> {
try {
const response = await get(`/api/v1/organizations/${orgId}/search-users?q=${encodeURIComponent(query)}&limit=${limit}`)
return response as unknown as ApiResponse<UserSearchResult[]>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to search users' }
}
}
/**
* Invite a user to organization directly (admin only)
*/
export async function inviteMember(
orgId: string,
req: InviteMemberRequest
): Promise<ApiResponse<void>> {
try {
const response = await post(`/api/v1/organizations/${orgId}/invite`, req)
return response as unknown as ApiResponse<void>
} catch (error: any) {
return { success: false, message: error.message || 'Failed to invite member' }
}
}