Files
Enterprise-Knowledge-Base/internal/application/service/tenant.go
T
wizardchen 9cce0c8e5e feat(system): consolidate system admin and settings into one Settings panel
Replace the standalone /platform/system/* routes with a single
"系统设置" section inside the canonical Settings modal. The previous
SystemLayout.vue / SystemAdmins.vue surfaces are removed and their
functionality (system admin roster, global settings) is hosted directly
in SystemSettings.vue under the standard `.section-header` /
`.settings-group` skeleton. Legacy URLs redirect to the modal section
so external bookmarks don't 404.

Backend:
- SystemSettingService.Reset + repo.Delete: drop the DB override for a
  key so the 3-tier resolver falls back to ENV / built-in default.
  Idempotent (resetting a never-persisted key returns nil); emits an
  audit row only on real deletions, invalidates the local cache, and
  publishes to peers via the existing pubsub channel.
- TenantService.BulkSetStorageQuota: overwrite every tenant's
  storage_quota in one statement. Powers POST /system/admin/tenants/
  apply-default-storage-quota; bypasses the per-tenant whitelist on
  PUT /tenants/:id which intentionally forbids storage_quota edits.
- AuditAction{SystemAdminPromoted,SystemAdminRevoked} constants and
  emitAdminAudit() in SystemHandler — promote / revoke now leave an
  audit trail with TenantID=0 and {target_email,target_username,
  idempotent|changed} in details.
- SystemSetting.LastModifiedByName: derived per-request display label
  (username, email fallback) so the UI shows "wizardchen" instead of
  a UUID prefix without storing a denormalised column.

Frontend:
- SystemSettings.vue rewritten against the Settings modal skeleton with
  auto-persisting controls (switch/select @change, input/inputnumber
  @blur, tag-input + per-delta popconfirm for SSRF whitelist and admin
  roster). auth.registration_mode change goes through an inline
  popconfirm; cancel rolls back. Reset / bulk-apply also inline
  popconfirms — no dialog modal for these per-row affordances.
- Priority hint panel surfaces the DB > ENV > default resolver order
  so operators can reason about "I set the env but it doesn't show up".
- Router: /platform/system, /platform/system/settings, /platform/system/
  admins are now compatibility redirects to /platform/settings?section=
  system-global.
- Settings modal sized 900x700 → 1080x780 and content-wrapper 600 → 760
  so the wider tables (members, system settings) breathe; <1100px
  viewport still flexes to the screen.
- i18n: system.globalSettings.* keys for title / description / loading /
  empty / badges / priority hint / per-key labels / reset / bulkApply /
  admins (label, placeholder, save messages, popconfirm copy) across
  zh-CN, en-US, ko-KR, ru-RU.

Misc:
- internal/utils/filesize.go doc: clarify MAX_FILE_SIZE_MB is a
  deploy-time-only knob (nginx + docreader + frontend each cache the
  env at startup); a SystemAdmin UI override would mislead operators
  because nginx would still 413. Until all four layers can hot-reload
  the limit in lockstep, this stays env-only.
- internal/utils/security.go: SSRF whitelist parser/runtime now drives
  off SystemSettingService for live updates; ENV remains the fallback
  for never-overridden deployments.
2026-05-26 21:13:56 +08:00

488 lines
14 KiB
Go

package service
import (
"context"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/base64"
"encoding/binary"
"errors"
"io"
"os"
"strings"
"time"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/Tencent/WeKnora/internal/utils"
werrors "github.com/Tencent/WeKnora/internal/errors"
)
var apiKeySecret = func() []byte {
return []byte(os.Getenv("TENANT_AES_KEY"))
}
// ListTenantsParams defines parameters for listing tenants with filtering and pagination
type ListTenantsParams struct {
Page int // Page number for pagination
PageSize int // Number of items per page
Status string // Filter by tenant status
Name string // Filter by tenant name
}
// tenantService implements the TenantService interface
type tenantService struct {
repo interfaces.TenantRepository // Repository for tenant data operations
}
// NewTenantService creates a new tenant service instance
func NewTenantService(repo interfaces.TenantRepository) interfaces.TenantService {
return &tenantService{repo: repo}
}
// CreateTenant creates a new tenant
func (s *tenantService) CreateTenant(ctx context.Context, tenant *types.Tenant) (*types.Tenant, error) {
logger.Info(ctx, "Start creating tenant")
if tenant.Name == "" {
logger.Error(ctx, "Tenant name cannot be empty")
return nil, errors.New("tenant name cannot be empty")
}
logger.Infof(ctx, "Creating tenant, name: %s", tenant.Name)
// Create tenant with initial values
tenant.APIKey = s.generateApiKey(0)
tenant.Status = "active"
tenant.CreatedAt = time.Now()
tenant.UpdatedAt = time.Now()
if err := s.validateStorageBucketUniqueness(ctx, tenant); err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_name": tenant.Name,
})
return nil, err
}
logger.Info(ctx, "Saving tenant information to database")
if err := s.repo.CreateTenant(ctx, tenant); err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_name": tenant.Name,
})
return nil, err
}
logger.Infof(ctx, "Tenant created successfully, ID: %d, generating official API Key", tenant.ID)
plaintextAPIKey := s.generateApiKey(tenant.ID)
tenant.APIKey = plaintextAPIKey
// Manually encrypt APIKey before update, because db.Updates() does not trigger BeforeSave hook
if key := utils.GetAESKey(); key != nil && tenant.APIKey != "" {
if encrypted, err := utils.EncryptAESGCM(tenant.APIKey, key); err == nil {
tenant.APIKey = encrypted
}
}
if err := s.repo.UpdateTenant(ctx, tenant); err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": tenant.ID,
"tenant_name": tenant.Name,
})
return nil, err
}
// Restore plaintext for the response so callers don't see enc:v1: ciphertext.
tenant.APIKey = plaintextAPIKey
logger.Infof(ctx, "Tenant creation and update completed, ID: %d, name: %s", tenant.ID, tenant.Name)
return tenant, nil
}
// GetTenantByID retrieves a tenant by their ID
func (s *tenantService) GetTenantByID(ctx context.Context, id uint64) (*types.Tenant, error) {
if id == 0 {
logger.Error(ctx, "Tenant ID cannot be 0")
return nil, errors.New("tenant ID cannot be 0")
}
tenant, err := s.repo.GetTenantByID(ctx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": id,
})
return nil, err
}
return tenant, nil
}
// GetTenantsByIDs batches GetTenantByID; returns a map keyed by tenant ID.
func (s *tenantService) GetTenantsByIDs(ctx context.Context, ids []uint64) (map[uint64]*types.Tenant, error) {
return s.repo.GetTenantsByIDs(ctx, ids)
}
// ListTenants retrieves a list of all tenants
func (s *tenantService) ListTenants(ctx context.Context) ([]*types.Tenant, error) {
tenants, err := s.repo.ListTenants(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
return nil, err
}
logger.Infof(ctx, "Tenant list retrieved successfully, total: %d", len(tenants))
return tenants, nil
}
// UpdateTenant updates an existing tenant's information
func (s *tenantService) UpdateTenant(ctx context.Context, tenant *types.Tenant) (*types.Tenant, error) {
if tenant.ID == 0 {
logger.Error(ctx, "Tenant ID cannot be 0")
return nil, errors.New("tenant ID cannot be 0")
}
logger.Infof(ctx, "Updating tenant, ID: %d, name: %s", tenant.ID, tenant.Name)
if err := s.validateStorageBucketUniqueness(ctx, tenant); err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": tenant.ID,
})
return nil, err
}
// Generate new API key if empty
if tenant.APIKey == "" {
logger.Info(ctx, "API Key is empty, generating new API Key")
tenant.APIKey = s.generateApiKey(tenant.ID)
}
tenant.UpdatedAt = time.Now()
logger.Info(ctx, "Saving tenant information to database")
if err := s.repo.UpdateTenant(ctx, tenant); err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": tenant.ID,
})
return nil, err
}
logger.Infof(ctx, "Tenant updated successfully, ID: %d", tenant.ID)
return tenant, nil
}
// DeleteTenant removes a tenant by their ID
func (s *tenantService) DeleteTenant(ctx context.Context, id uint64) error {
logger.Info(ctx, "Start deleting tenant")
if id == 0 {
logger.Error(ctx, "Tenant ID cannot be 0")
return errors.New("tenant ID cannot be 0")
}
logger.Infof(ctx, "Deleting tenant, ID: %d", id)
// Get tenant information for logging
tenant, err := s.repo.GetTenantByID(ctx, id)
if err != nil {
if err.Error() == "record not found" {
logger.Warnf(ctx, "Tenant to be deleted does not exist, ID: %d", id)
} else {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": id,
})
return err
}
} else {
logger.Infof(ctx, "Deleting tenant, ID: %d, name: %s", id, tenant.Name)
}
err = s.repo.DeleteTenant(ctx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": id,
})
return err
}
logger.Infof(ctx, "Tenant deleted successfully, ID: %d", id)
return nil
}
// UpdateAPIKey updates the API key for a specific tenant
func (s *tenantService) UpdateAPIKey(ctx context.Context, id uint64) (string, error) {
logger.Info(ctx, "Start updating tenant API Key")
if id == 0 {
logger.Error(ctx, "Tenant ID cannot be 0")
return "", errors.New("tenant ID cannot be 0")
}
tenant, err := s.repo.GetTenantByID(ctx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": id,
})
return "", err
}
logger.Infof(ctx, "Generating new API Key for tenant, ID: %d", id)
plaintextAPIKey := s.generateApiKey(tenant.ID)
tenant.APIKey = plaintextAPIKey
// Manually encrypt APIKey before update, because db.Updates() does not trigger BeforeSave hook
if key := utils.GetAESKey(); key != nil && tenant.APIKey != "" {
if encrypted, err := utils.EncryptAESGCM(tenant.APIKey, key); err == nil {
tenant.APIKey = encrypted
}
}
if err := s.repo.UpdateTenant(ctx, tenant); err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": id,
})
return "", err
}
logger.Infof(ctx, "Tenant API Key updated successfully, ID: %d", id)
return plaintextAPIKey, nil
}
// generateApiKey generates a secure API key for tenant authentication
func (r *tenantService) generateApiKey(tenantID uint64) string {
// 1. Convert tenant_id to bytes
idBytes := make([]byte, 8)
binary.LittleEndian.PutUint64(idBytes, uint64(tenantID))
// 2. Encrypt tenant_id using AES-GCM
block, err := aes.NewCipher(apiKeySecret())
if err != nil {
panic("Failed to create AES cipher: " + err.Error())
}
nonce := make([]byte, 12)
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
panic(err.Error())
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
panic("Failed to create GCM cipher: " + err.Error())
}
ciphertext := aesgcm.Seal(nil, nonce, idBytes, nil)
// 3. Combine nonce and ciphertext, then encode with base64
combined := append(nonce, ciphertext...)
encoded := base64.RawURLEncoding.EncodeToString(combined)
// Create final API Key in format: sk-{encrypted_part}
return "sk-" + encoded
}
// ExtractTenantIDFromAPIKey extracts the tenant ID from an API key
func (r *tenantService) ExtractTenantIDFromAPIKey(apiKey string) (uint64, error) {
// 1. Validate format and extract encrypted part
parts := strings.SplitN(apiKey, "-", 2)
if len(parts) != 2 || parts[0] != "sk" {
return 0, errors.New("invalid API key format")
}
// 2. Decode the base64 part
encryptedData, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil {
return 0, errors.New("invalid API key encoding")
}
// 3. Separate nonce and ciphertext
if len(encryptedData) < 12 {
return 0, errors.New("invalid API key length")
}
nonce, ciphertext := encryptedData[:12], encryptedData[12:]
// 4. Decrypt
block, err := aes.NewCipher(apiKeySecret())
if err != nil {
return 0, errors.New("decryption error")
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return 0, errors.New("decryption error")
}
plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
if err != nil {
return 0, errors.New("API key is invalid or has been tampered with")
}
// 5. Convert back to tenant_id
tenantID := binary.LittleEndian.Uint64(plaintext)
return tenantID, nil
}
// ListAllTenants lists all tenants (for users with cross-tenant access permission)
// This method returns all tenants without filtering, intended for admin users
func (s *tenantService) ListAllTenants(ctx context.Context) ([]*types.Tenant, error) {
tenants, err := s.repo.ListTenants(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
return nil, err
}
logger.Infof(ctx, "All tenants list retrieved successfully, total: %d", len(tenants))
return tenants, nil
}
// BulkSetStorageQuota delegates to the repository. Validation is
// minimal — quotaBytes <= 0 is rejected because the storage-quota
// enforcement in knowledge_create.go treats <=0 as "unlimited", which
// is never what a SystemAdmin pressing "apply default" intends.
func (s *tenantService) BulkSetStorageQuota(ctx context.Context, quotaBytes int64) (int64, error) {
if quotaBytes <= 0 {
return 0, errors.New("quota must be positive")
}
affected, err := s.repo.BulkSetStorageQuota(ctx, quotaBytes)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{"quota_bytes": quotaBytes})
return 0, err
}
logger.Infof(ctx, "Bulk set storage_quota=%d on %d tenants", quotaBytes, affected)
return affected, nil
}
// SearchTenants searches tenants with pagination and filters
func (s *tenantService) SearchTenants(ctx context.Context, keyword string, tenantID uint64, page, pageSize int) ([]*types.Tenant, int64, error) {
tenants, total, err := s.repo.SearchTenants(ctx, keyword, tenantID, page, pageSize)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"keyword": keyword,
"tenantID": tenantID,
"page": page,
"pageSize": pageSize,
})
return nil, 0, err
}
logger.Infof(ctx, "Tenants search completed, keyword: %s, tenantID: %d, page: %d, pageSize: %d, total: %d, found: %d",
keyword, tenantID, page, pageSize, total, len(tenants))
return tenants, total, nil
}
// GetTenantByIDForUser gets a tenant by ID with permission check
// This method verifies that the user has permission to access the tenant
func (s *tenantService) GetTenantByIDForUser(ctx context.Context, tenantID uint64, userID string) (*types.Tenant, error) {
tenant, err := s.repo.GetTenantByID(ctx, tenantID)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tenant_id": tenantID,
"user_id": userID,
})
return nil, err
}
return tenant, nil
}
func (s *tenantService) GetWeKnoraCloudCredentials(ctx context.Context) *types.WeKnoraCloudCredentials {
// Try to get tenant info from context first (already loaded by middleware).
// CredentialsConfig.Scan handles decryption, so credentials are ready to use.
if tenant, ok := types.TenantInfoFromContext(ctx); ok {
if creds := tenant.Credentials.GetWeKnoraCloud(); creds != nil {
return creds
}
}
// Fallback: load tenant from repo by tenantID
tenantID, ok := types.TenantIDFromContext(ctx)
if !ok {
return nil
}
tenant, err := s.repo.GetTenantByID(ctx, tenantID)
if err != nil || tenant == nil {
return nil
}
return tenant.Credentials.GetWeKnoraCloud()
}
func (s *tenantService) validateStorageBucketUniqueness(ctx context.Context, tenant *types.Tenant) error {
if tenant.StorageEngineConfig == nil {
return nil
}
// Fetch existing tenant from DB to compare
var oldTenant *types.Tenant
if tenant.ID != 0 {
var err error
oldTenant, err = s.repo.GetTenantByID(ctx, tenant.ID)
if err != nil && err.Error() != "tenant not found" && err.Error() != "record not found" {
return err
}
}
// Fetch ALL tenants to check for collision.
allTenants, err := s.repo.ListTenants(ctx)
if err != nil {
return err
}
// Helper to get bucket names from a StorageEngineConfig
getBuckets := func(cfg *types.StorageEngineConfig) map[string]string {
if cfg == nil {
return nil
}
res := make(map[string]string)
if cfg.MinIO != nil && cfg.MinIO.BucketName != "" {
res["minio"] = cfg.MinIO.BucketName
}
if cfg.COS != nil && cfg.COS.BucketName != "" {
res["cos"] = cfg.COS.BucketName
}
if cfg.TOS != nil && cfg.TOS.BucketName != "" {
res["tos"] = cfg.TOS.BucketName
}
if cfg.S3 != nil && cfg.S3.BucketName != "" {
res["s3"] = cfg.S3.BucketName
}
if cfg.OSS != nil && cfg.OSS.BucketName != "" {
res["oss"] = cfg.OSS.BucketName
}
return res
}
var oldBuckets map[string]string
if oldTenant != nil {
oldBuckets = getBuckets(oldTenant.StorageEngineConfig)
}
newBuckets := getBuckets(tenant.StorageEngineConfig)
// Collect buckets used by other tenants
usedByOthers := make(map[string]map[string]bool) // provider -> set of bucket names
for _, t := range allTenants {
if t.ID == tenant.ID {
continue
}
tb := getBuckets(t.StorageEngineConfig)
for p, b := range tb {
if usedByOthers[p] == nil {
usedByOthers[p] = make(map[string]bool)
}
usedByOthers[p][b] = true
}
}
// Check if any NEW bucket is already used by someone else, AND it's different from the OLD bucket
for p, b := range newBuckets {
oldB := oldBuckets[p]
if b != oldB { // User is trying to change their bucket name or set a new one
if usedByOthers[p] != nil && usedByOthers[p][b] {
return werrors.NewBadRequestError("存储桶名称「" + b + "」已被其他租户使用,为保证数据隔离,请使用其他名称")
}
}
}
return nil
}