Files
Enterprise-Knowledge-Base/internal/application/repository/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

186 lines
6.1 KiB
Go

package repository
import (
"context"
"errors"
"strings"
"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"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
var (
ErrTenantNotFound = errors.New("tenant not found")
ErrTenantHasKnowledgeBase = errors.New("tenant has associated knowledge bases")
)
// tenantRepository implements tenant repository interface
type tenantRepository struct {
db *gorm.DB
}
// NewTenantRepository creates a new tenant repository
func NewTenantRepository(db *gorm.DB) interfaces.TenantRepository {
return &tenantRepository{db: db}
}
// CreateTenant creates tenant
func (r *tenantRepository) CreateTenant(ctx context.Context, tenant *types.Tenant) error {
return r.db.WithContext(ctx).Create(tenant).Error
}
// GetTenantByID gets tenant by ID
func (r *tenantRepository) GetTenantByID(ctx context.Context, id uint64) (*types.Tenant, error) {
var tenant types.Tenant
if err := r.db.WithContext(ctx).Where("id = ?", id).First(&tenant).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, ErrTenantNotFound
}
return nil, err
}
return &tenant, nil
}
// GetTenantsByIDs batches GetTenantByID with a single IN-list query.
// Returns a map keyed by tenant ID; missing rows are simply absent from
// the map (no error). An empty input slice short-circuits to an empty map
// without hitting the database.
func (r *tenantRepository) GetTenantsByIDs(ctx context.Context, ids []uint64) (map[uint64]*types.Tenant, error) {
if len(ids) == 0 {
return map[uint64]*types.Tenant{}, nil
}
var tenants []*types.Tenant
if err := r.db.WithContext(ctx).Where("id IN ?", ids).Find(&tenants).Error; err != nil {
return nil, err
}
out := make(map[uint64]*types.Tenant, len(tenants))
for _, t := range tenants {
if t != nil {
out[t.ID] = t
}
}
return out, nil
}
// ListTenants lists all tenants
func (r *tenantRepository) ListTenants(ctx context.Context) ([]*types.Tenant, error) {
var tenants []*types.Tenant
if err := r.db.WithContext(ctx).Order("created_at DESC").Find(&tenants).Error; err != nil {
return nil, err
}
return tenants, nil
}
// SearchTenants searches tenants with pagination and filters
func (r *tenantRepository) SearchTenants(ctx context.Context, keyword string, tenantID uint64, page, pageSize int) ([]*types.Tenant, int64, error) {
var tenants []*types.Tenant
var total int64
query := r.db.WithContext(ctx).Model(&types.Tenant{})
// Build search conditions
if tenantID > 0 && keyword != "" {
escaped := escapeLikeKeyword(keyword)
query = query.Where("id = ? OR name LIKE ? OR description LIKE ?", tenantID, "%"+escaped+"%", "%"+escaped+"%")
} else if tenantID > 0 {
query = query.Where("id = ?", tenantID)
} else if keyword != "" {
escaped := escapeLikeKeyword(keyword)
query = query.Where("name LIKE ? OR description LIKE ?", "%"+escaped+"%", "%"+escaped+"%")
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Apply pagination
if page > 0 && pageSize > 0 {
offset := (page - 1) * pageSize
query = query.Offset(offset).Limit(pageSize)
}
// Order by created_at DESC
query = query.Order("created_at DESC")
// Execute query
if err := query.Find(&tenants).Error; err != nil {
return nil, 0, err
}
return tenants, total, nil
}
// UpdateTenant updates tenant.
// Handles api_key carefully because db.Updates() does not trigger the BeforeSave
// GORM hook. Without this guard, AfterFind-decrypted plaintext would silently
// overwrite the encrypted value in the database.
//
// Strategy:
// - enc:v1:… (pre-encrypted by CreateTenant / UpdateAPIKey): write as-is.
// - plaintext (decrypted by AfterFind): blank it so GORM skips the column.
// - SYSTEM_AES_KEY not set: write as-is (encryption disabled).
//
// The caller's in-memory struct is always restored after the write.
func (r *tenantRepository) UpdateTenant(ctx context.Context, tenant *types.Tenant) error {
origAPIKey := tenant.APIKey
if key := utils.GetAESKey(); key != nil && tenant.APIKey != "" &&
!strings.HasPrefix(tenant.APIKey, utils.EncPrefix) {
// Plaintext from AfterFind — do not write back; let the DB keep its
// existing encrypted value untouched.
tenant.APIKey = ""
}
err := r.db.WithContext(ctx).Model(&types.Tenant{}).Where("id = ?", tenant.ID).Updates(tenant).Error
tenant.APIKey = origAPIKey
return err
}
// DeleteTenant deletes tenant
func (r *tenantRepository) DeleteTenant(ctx context.Context, id uint64) error {
return r.db.WithContext(ctx).Where("id = ?", id).Delete(&types.Tenant{}).Error
}
func (r *tenantRepository) AdjustStorageUsed(ctx context.Context, tenantID uint64, delta int64) error {
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var tenant types.Tenant
// 使用悲观锁确保并发安全
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&tenant, tenantID).Error; err != nil {
return err
}
tenant.StorageUsed += delta
// 保存更新并验证业务规则
if tenant.StorageUsed < 0 {
logger.Errorf(ctx, "tenant storage used is negative %d: %d", tenant.ID, tenant.StorageUsed)
tenant.StorageUsed = 0
}
return tx.Save(&tenant).Error
})
}
// BulkSetStorageQuota writes quotaBytes to storage_quota for every
// tenant in one statement. We don't WHERE-filter (the action is
// "apply globally"), so the affected count equals the row count of
// the tenants table.
//
// No transaction here: the operation is a single statement and we
// don't want to hold a long lock just to update a single column. If
// a concurrent CreateTenant lands in the middle, the new row gets
// the new default via the system-setting resolver in the handler —
// no risk of the new tenant being skipped.
func (r *tenantRepository) BulkSetStorageQuota(ctx context.Context, quotaBytes int64) (int64, error) {
res := r.db.WithContext(ctx).
Model(&types.Tenant{}).
Where("1 = 1"). // GORM refuses unconditional UPDATEs without an explicit WHERE
Update("storage_quota", quotaBytes)
if res.Error != nil {
return 0, res.Error
}
return res.RowsAffected, nil
}