Files
Enterprise-Knowledge-Base/internal/application/service/kbshare.go
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

380 lines
12 KiB
Go

package service
import (
"context"
"errors"
"time"
"github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/google/uuid"
)
var (
ErrShareNotFound = errors.New("share not found")
ErrSharePermissionDenied = errors.New("permission denied for this share operation")
ErrKBNotFound = errors.New("knowledge base not found")
ErrNotKBOwner = errors.New("only knowledge base owner can share")
// ErrOrgRoleCannotShare: only editors and admins in the org can share KBs to that org; viewers cannot
ErrOrgRoleCannotShare = errors.New("only editors and admins can share knowledge bases to this organization")
)
// kbShareService implements KBShareService interface
type kbShareService struct {
shareRepo interfaces.KBShareRepository
orgRepo interfaces.OrganizationRepository
kbRepo interfaces.KnowledgeBaseRepository
kgRepo interfaces.KnowledgeRepository
chunkRepo interfaces.ChunkRepository
}
// NewKBShareService creates a new knowledge base share service
func NewKBShareService(
shareRepo interfaces.KBShareRepository,
orgRepo interfaces.OrganizationRepository,
kbRepo interfaces.KnowledgeBaseRepository,
kgRepo interfaces.KnowledgeRepository,
chunkRepo interfaces.ChunkRepository,
) interfaces.KBShareService {
return &kbShareService{
shareRepo: shareRepo,
orgRepo: orgRepo,
kbRepo: kbRepo,
kgRepo: kgRepo,
chunkRepo: chunkRepo,
}
}
// ShareKnowledgeBase shares a knowledge base to an organization
func (s *kbShareService) ShareKnowledgeBase(ctx context.Context, kbID string, orgID string, userID string, tenantID uint64, permission types.OrgMemberRole) (*types.KnowledgeBaseShare, error) {
logger.Infof(ctx, "Sharing knowledge base %s to organization %s", kbID, orgID)
// Verify knowledge base exists and user is the owner (same tenant)
kb, err := s.kbRepo.GetKnowledgeBaseByID(ctx, kbID)
if err != nil {
return nil, ErrKBNotFound
}
// Check if user's tenant owns the knowledge base
if kb.TenantID != tenantID {
return nil, ErrNotKBOwner
}
// Verify organization exists
_, err = s.orgRepo.GetByID(ctx, orgID)
if err != nil {
if errors.Is(err, repository.ErrOrganizationNotFound) {
return nil, ErrOrgNotFound
}
return nil, err
}
// Check if user is a member of the organization and has at least editor role (viewers cannot share KBs to the org)
member, err := s.orgRepo.GetMember(ctx, orgID, userID)
if err != nil {
if errors.Is(err, repository.ErrOrgMemberNotFound) {
return nil, ErrUserNotInOrg
}
return nil, err
}
if !member.Role.HasPermission(types.OrgRoleEditor) {
return nil, ErrOrgRoleCannotShare
}
if !permission.IsValid() {
return nil, ErrInvalidRole
}
share := &types.KnowledgeBaseShare{
ID: uuid.New().String(),
KnowledgeBaseID: kbID,
OrganizationID: orgID,
SharedByUserID: userID,
SourceTenantID: tenantID,
Permission: permission,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if err := s.shareRepo.Create(ctx, share); err != nil {
if errors.Is(err, repository.ErrKBShareAlreadyExists) {
// Update existing share
existingShare, err := s.shareRepo.GetByKBAndOrg(ctx, kbID, orgID)
if err != nil {
return nil, err
}
existingShare.Permission = permission
existingShare.UpdatedAt = time.Now()
if err := s.shareRepo.Update(ctx, existingShare); err != nil {
return nil, err
}
return existingShare, nil
}
return nil, err
}
logger.Infof(ctx, "Knowledge base %s shared successfully to organization %s", kbID, orgID)
return share, nil
}
// UpdateSharePermission updates the permission of a share
func (s *kbShareService) UpdateSharePermission(ctx context.Context, shareID string, permission types.OrgMemberRole, userID string) error {
share, err := s.shareRepo.GetByID(ctx, shareID)
if err != nil {
if errors.Is(err, repository.ErrKBShareNotFound) {
return ErrShareNotFound
}
return err
}
// Only the user who shared can update
if share.SharedByUserID != userID {
return ErrSharePermissionDenied
}
if !permission.IsValid() {
return ErrInvalidRole
}
share.Permission = permission
share.UpdatedAt = time.Now()
return s.shareRepo.Update(ctx, share)
}
// RemoveShare removes a share.
// Allowed if: (1) current user is the sharer, or (2) current user is admin of the target organization.
// Org admins can unlink any KB shared to their org (e.g. content governance, sharer left).
func (s *kbShareService) RemoveShare(ctx context.Context, shareID string, userID string) error {
share, err := s.shareRepo.GetByID(ctx, shareID)
if err != nil {
if errors.Is(err, repository.ErrKBShareNotFound) {
return ErrShareNotFound
}
return err
}
// Sharer can always remove their own share
if share.SharedByUserID == userID {
return s.shareRepo.Delete(ctx, shareID)
}
// Org admin can remove any share targeting their organization
member, err := s.orgRepo.GetMember(ctx, share.OrganizationID, userID)
if err == nil && member.Role == types.OrgRoleAdmin {
return s.shareRepo.Delete(ctx, shareID)
}
return ErrSharePermissionDenied
}
// ListSharesByKnowledgeBase lists all shares for a knowledge base
func (s *kbShareService) ListSharesByKnowledgeBase(ctx context.Context, kbID string) ([]*types.KnowledgeBaseShare, error) {
return s.shareRepo.ListByKnowledgeBase(ctx, kbID)
}
// ListSharesByOrganization lists all shares for an organization
func (s *kbShareService) ListSharesByOrganization(ctx context.Context, orgID string) ([]*types.KnowledgeBaseShare, error) {
return s.shareRepo.ListByOrganization(ctx, orgID)
}
// ListSharedKnowledgeBases lists all knowledge bases shared to the user through organizations
// It filters out knowledge bases that belong to the user's own tenant
// It deduplicates knowledge bases that are shared to multiple organizations the user belongs to
func (s *kbShareService) ListSharedKnowledgeBases(ctx context.Context, userID string, currentTenantID uint64) ([]*types.SharedKnowledgeBaseInfo, error) {
shares, err := s.shareRepo.ListSharedKBsForUser(ctx, userID)
if err != nil {
return nil, err
}
// Use a map to deduplicate by knowledge base ID, keeping the one with highest permission
kbInfoMap := make(map[string]*types.SharedKnowledgeBaseInfo)
for _, share := range shares {
// Skip knowledge bases that belong to the user's own tenant
// (user already has full ownership of these)
if share.SourceTenantID == currentTenantID {
continue
}
// Skip if knowledge base is nil
if share.KnowledgeBase == nil {
continue
}
kbID := share.KnowledgeBase.ID
// Get user's role in the organization
member, err := s.orgRepo.GetMember(ctx, share.OrganizationID, userID)
if err != nil {
continue // Skip if user is not a member anymore
}
// Effective permission is the lower of share permission and user's org role
effectivePermission := share.Permission
if !member.Role.HasPermission(share.Permission) {
effectivePermission = member.Role
}
kb := share.KnowledgeBase
// Calculate knowledge/chunk count based on type
switch kb.Type {
case types.KnowledgeBaseTypeDocument:
knowledgeCount, err := s.kgRepo.CountKnowledgeByKnowledgeBaseID(ctx, share.SourceTenantID, kb.ID)
if err != nil {
logger.Warnf(ctx, "Failed to get knowledge count for shared KB %s: %v", kb.ID, err)
} else {
kb.KnowledgeCount = knowledgeCount
}
case types.KnowledgeBaseTypeFAQ:
chunkCount, err := s.chunkRepo.CountChunksByKnowledgeBaseID(ctx, share.SourceTenantID, kb.ID)
if err != nil {
logger.Warnf(ctx, "Failed to get chunk count for shared KB %s: %v", kb.ID, err)
} else {
kb.ChunkCount = chunkCount
}
}
info := &types.SharedKnowledgeBaseInfo{
KnowledgeBase: kb,
ShareID: share.ID,
OrganizationID: share.OrganizationID,
OrgName: "",
Permission: effectivePermission,
SourceTenantID: share.SourceTenantID,
SharedAt: share.CreatedAt,
}
if share.Organization != nil {
info.OrgName = share.Organization.Name
}
// Check if we already have this knowledge base
existing, exists := kbInfoMap[kbID]
if !exists {
// First time seeing this KB, add it
kbInfoMap[kbID] = info
} else {
// KB already exists, keep the one with higher permission
// Permission hierarchy: admin(3) > editor(2) > viewer(1)
// If current permission is higher than existing, replace
// This handles the case where a user belongs to multiple orgs with different permissions
if effectivePermission.HasPermission(existing.Permission) && effectivePermission != existing.Permission {
// Current permission is higher, replace with higher permission
kbInfoMap[kbID] = info
}
// If existing permission is higher or equal, keep existing (no change needed)
}
}
// Convert map to slice
result := make([]*types.SharedKnowledgeBaseInfo, 0, len(kbInfoMap))
for _, info := range kbInfoMap {
result = append(result, info)
}
return result, nil
}
// GetShare gets a share by ID
func (s *kbShareService) GetShare(ctx context.Context, shareID string) (*types.KnowledgeBaseShare, error) {
share, err := s.shareRepo.GetByID(ctx, shareID)
if err != nil {
if errors.Is(err, repository.ErrKBShareNotFound) {
return nil, ErrShareNotFound
}
return nil, err
}
return share, nil
}
// GetShareByKBAndOrg gets a share by knowledge base and organization
func (s *kbShareService) GetShareByKBAndOrg(ctx context.Context, kbID string, orgID string) (*types.KnowledgeBaseShare, error) {
share, err := s.shareRepo.GetByKBAndOrg(ctx, kbID, orgID)
if err != nil {
if errors.Is(err, repository.ErrKBShareNotFound) {
return nil, ErrShareNotFound
}
return nil, err
}
return share, nil
}
// CheckUserKBPermission checks a user's permission for a knowledge base
// Returns: permission level, isShared, error
func (s *kbShareService) CheckUserKBPermission(ctx context.Context, kbID string, userID string) (types.OrgMemberRole, bool, error) {
// Get all shares for this knowledge base
shares, err := s.shareRepo.ListByKnowledgeBase(ctx, kbID)
if err != nil {
return "", false, err
}
var highestPermission types.OrgMemberRole
isShared := false
for _, share := range shares {
// Check if user is a member of the organization
member, err := s.orgRepo.GetMember(ctx, share.OrganizationID, userID)
if err != nil {
continue // User is not a member of this org
}
isShared = true
// Effective permission is the lower of share permission and user's org role
effectivePermission := share.Permission
if !member.Role.HasPermission(share.Permission) {
effectivePermission = member.Role
}
// Keep the highest permission
if highestPermission == "" || effectivePermission.HasPermission(highestPermission) {
highestPermission = effectivePermission
}
}
return highestPermission, isShared, nil
}
// HasKBPermission checks if a user has at least the required permission level for a knowledge base
func (s *kbShareService) HasKBPermission(ctx context.Context, kbID string, userID string, requiredRole types.OrgMemberRole) (bool, error) {
permission, isShared, err := s.CheckUserKBPermission(ctx, kbID, userID)
if err != nil {
return false, err
}
if !isShared {
return false, nil
}
return permission.HasPermission(requiredRole), nil
}
// GetKBSourceTenant gets the source tenant ID for a shared knowledge base
func (s *kbShareService) GetKBSourceTenant(ctx context.Context, kbID string) (uint64, error) {
// First check if there are any shares for this KB
shares, err := s.shareRepo.ListByKnowledgeBase(ctx, kbID)
if err != nil {
return 0, err
}
if len(shares) > 0 {
return shares[0].SourceTenantID, nil
}
// If not shared, get the tenant from the knowledge base itself
kb, err := s.kbRepo.GetKnowledgeBaseByID(ctx, kbID)
if err != nil {
return 0, ErrKBNotFound
}
return kb.TenantID, nil
}
// CountSharesByKnowledgeBaseIDs counts the number of shares for multiple knowledge bases
func (s *kbShareService) CountSharesByKnowledgeBaseIDs(ctx context.Context, kbIDs []string) (map[string]int64, error) {
return s.shareRepo.CountSharesByKnowledgeBaseIDs(ctx, kbIDs)
}