""" InsightFlow Phase 8 - 多租户 SaaS 架构管理模块 功能： 1. 租户隔离（数据、配置、资源完全隔离） 2. 自定义域名绑定（CNAME 支持） 3. 品牌白标（Logo、主题色、自定义 CSS） 4. 租户级权限管理 作者: InsightFlow Team """ import hashlib import json import logging import re import sqlite3 import uuid from dataclasses import asdict, dataclass from datetime import datetime from enum import StrEnum from typing import Any logger = logging.getLogger(__name__) class TenantLimits: """租户资源限制常量""" FREE_MAX_PROJECTS = 3 FREE_MAX_STORAGE_MB = 100 FREE_MAX_TRANSCRIPTION_MINUTES = 60 FREE_MAX_API_CALLS_PER_DAY = 100 FREE_MAX_TEAM_MEMBERS = 2 FREE_MAX_ENTITIES = 100 PRO_MAX_PROJECTS = 20 PRO_MAX_STORAGE_MB = 1000 PRO_MAX_TRANSCRIPTION_MINUTES = 600 PRO_MAX_API_CALLS_PER_DAY = 10000 PRO_MAX_TEAM_MEMBERS = 10 PRO_MAX_ENTITIES = 1000 UNLIMITED = -1 class TenantStatus(StrEnum): """租户状态""" ACTIVE = "active" # 活跃 SUSPENDED = "suspended" # 暂停 TRIAL = "trial" # 试用 EXPIRED = "expired" # 过期 PENDING = "pending" # 待激活 class TenantTier(StrEnum): """租户订阅层级""" FREE = "free" # 免费版 PRO = "pro" # 专业版 ENTERPRISE = "enterprise" # 企业版 class TenantRole(StrEnum): """租户角色""" OWNER = "owner" # 所有者 ADMIN = "admin" # 管理员 MEMBER = "member" # 成员 VIEWER = "viewer" # 查看者 class DomainStatus(StrEnum): """域名状态""" PENDING = "pending" # 待验证 VERIFIED = "verified" # 已验证 FAILED = "failed" # 验证失败 EXPIRED = "expired" # 已过期 @dataclass class Tenant: """租户数据类""" id: str name: str slug: str # URL 友好的唯一标识 description: str | None tier: str # free/pro/enterprise status: str # active/suspended/trial/expired/pending owner_id: str # 所有者用户ID created_at: datetime updated_at: datetime expires_at: datetime | None # 订阅过期时间 settings: dict[str, Any] # 租户级设置 resource_limits: dict[str, Any] # 资源限制 metadata: dict[str, Any] # 元数据 @dataclass class TenantDomain: """租户域名数据类""" id: str tenant_id: str domain: str # 自定义域名 status: str # pending/verified/failed/expired verification_token: str # 验证令牌 verification_method: str # dns/file verified_at: datetime | None created_at: datetime updated_at: datetime is_primary: bool # 是否主域名 ssl_enabled: bool # SSL 是否启用 ssl_expires_at: datetime | None @dataclass class TenantBranding: """租户品牌配置数据类""" id: str tenant_id: str logo_url: str | None # Logo URL favicon_url: str | None # Favicon URL primary_color: str | None # 主题主色 secondary_color: str | None # 主题次色 custom_css: str | None # 自定义 CSS custom_js: str | None # 自定义 JS login_page_bg: str | None # 登录页背景 email_template: str | None # 邮件模板 created_at: datetime updated_at: datetime @dataclass class TenantMember: """租户成员数据类""" id: str tenant_id: str user_id: str email: str role: str # owner/admin/member/viewer permissions: list[str] # 具体权限列表 invited_by: str | None # 邀请者 invited_at: datetime joined_at: datetime | None last_active_at: datetime | None status: str # active/pending/suspended @dataclass class TenantPermission: """租户权限定义数据类""" id: str tenant_id: str name: str # 权限名称 code: str # 权限代码 description: str | None resource_type: str # project/entity/api/etc actions: list[str] # create/read/update/delete/etc conditions: dict | None # 条件限制 created_at: datetime class TenantManager: """租户管理器 - 多租户 SaaS 架构核心""" # 默认资源限制配置 - 使用常量 DEFAULT_LIMITS = { TenantTier.FREE: { "max_projects": TenantLimits.FREE_MAX_PROJECTS, "max_storage_mb": TenantLimits.FREE_MAX_STORAGE_MB, "max_transcription_minutes": TenantLimits.FREE_MAX_TRANSCRIPTION_MINUTES, "max_api_calls_per_day": TenantLimits.FREE_MAX_API_CALLS_PER_DAY, "max_team_members": TenantLimits.FREE_MAX_TEAM_MEMBERS, "max_entities": TenantLimits.FREE_MAX_ENTITIES, "features": ["basic_analysis", "export_png"], }, TenantTier.PRO: { "max_projects": TenantLimits.PRO_MAX_PROJECTS, "max_storage_mb": TenantLimits.PRO_MAX_STORAGE_MB, "max_transcription_minutes": TenantLimits.PRO_MAX_TRANSCRIPTION_MINUTES, "max_api_calls_per_day": TenantLimits.PRO_MAX_API_CALLS_PER_DAY, "max_team_members": TenantLimits.PRO_MAX_TEAM_MEMBERS, "max_entities": TenantLimits.PRO_MAX_ENTITIES, "features": [ "basic_analysis", "advanced_analysis", "export_all", "api_access", "webhooks", "collaboration", ], }, TenantTier.ENTERPRISE: { "max_projects": TenantLimits.UNLIMITED, # 无限制 "max_storage_mb": TenantLimits.UNLIMITED, "max_transcription_minutes": TenantLimits.UNLIMITED, "max_api_calls_per_day": TenantLimits.UNLIMITED, "max_team_members": TenantLimits.UNLIMITED, "max_entities": TenantLimits.UNLIMITED, "features": ["all"], # 所有功能 }, } # 角色权限映射 ROLE_PERMISSIONS = { TenantRole.OWNER: [ "tenant:*", "project:*", "member:*", "billing:*", "settings:*", "api:*", "export:*", ], TenantRole.ADMIN: [ "tenant:read", "project:*", "member:*", "billing:read", "settings:*", "api:*", "export:*", ], TenantRole.MEMBER: [ "tenant:read", "project:create", "project:read", "project:update", "member:read", "export:basic", ], TenantRole.VIEWER: ["tenant:read", "project:read", "member:read"], } # 权限名称映射 PERMISSION_NAMES = { "tenant:*": "租户完全控制", "tenant:read": "查看租户信息", "project:*": "项目完全控制", "project:create": "创建项目", "project:read": "查看项目", "project:update": "编辑项目", "member:*": "成员完全控制", "member:read": "查看成员", "billing:*": "账单完全控制", "billing:read": "查看账单", "settings:*": "设置完全控制", "api:*": "API完全控制", "export:*": "导出完全控制", "export:basic": "基础导出", } def __init__(self, db_path: str = "insightflow.db") -> None: self.db_path = db_path self._init_db() def _get_connection(self) -> sqlite3.Connection: """获取数据库连接""" conn = sqlite3.connect(self.db_path) conn.row_factory = sqlite3.Row return conn def _init_db(self) -> None: """初始化数据库表""" conn = self._get_connection() try: cursor = conn.cursor() # 租户主表 cursor.execute(""" CREATE TABLE IF NOT EXISTS tenants ( id TEXT PRIMARY KEY, name TEXT NOT NULL, slug TEXT UNIQUE NOT NULL, description TEXT, tier TEXT DEFAULT 'free', status TEXT DEFAULT 'pending', owner_id TEXT NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, expires_at TIMESTAMP, settings TEXT DEFAULT '{}', resource_limits TEXT DEFAULT '{}', metadata TEXT DEFAULT '{}' ) """) # 租户域名表 cursor.execute(""" CREATE TABLE IF NOT EXISTS tenant_domains ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, domain TEXT UNIQUE NOT NULL, status TEXT DEFAULT 'pending', verification_token TEXT NOT NULL, verification_method TEXT DEFAULT 'dns', verified_at TIMESTAMP, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, is_primary INTEGER DEFAULT 0, ssl_enabled INTEGER DEFAULT 0, ssl_expires_at TIMESTAMP, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE ) """) # 租户品牌配置表 cursor.execute(""" CREATE TABLE IF NOT EXISTS tenant_branding ( id TEXT PRIMARY KEY, tenant_id TEXT UNIQUE NOT NULL, logo_url TEXT, favicon_url TEXT, primary_color TEXT, secondary_color TEXT, custom_css TEXT, custom_js TEXT, login_page_bg TEXT, email_template TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE ) """) # 租户成员表 cursor.execute(""" CREATE TABLE IF NOT EXISTS tenant_members ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, user_id TEXT, email TEXT NOT NULL, role TEXT DEFAULT 'member', permissions TEXT DEFAULT '[]', invited_by TEXT, invited_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, joined_at TIMESTAMP, last_active_at TIMESTAMP, status TEXT DEFAULT 'pending', updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE ) """) # 租户权限定义表 cursor.execute(""" CREATE TABLE IF NOT EXISTS tenant_permissions ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, name TEXT NOT NULL, code TEXT NOT NULL, description TEXT, resource_type TEXT NOT NULL, actions TEXT NOT NULL, conditions TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE, UNIQUE(tenant_id, code) ) """) # 租户资源使用统计表 cursor.execute(""" CREATE TABLE IF NOT EXISTS tenant_usage ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, date DATE NOT NULL, storage_bytes INTEGER DEFAULT 0, transcription_seconds INTEGER DEFAULT 0, api_calls INTEGER DEFAULT 0, projects_count INTEGER DEFAULT 0, entities_count INTEGER DEFAULT 0, members_count INTEGER DEFAULT 0, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE, UNIQUE(tenant_id, date) ) """) # 创建索引 cursor.execute("CREATE INDEX IF NOT EXISTS idx_tenants_slug ON tenants(slug)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_tenants_owner ON tenants(owner_id)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_tenants_status ON tenants(status)") cursor.execute( "CREATE INDEX IF NOT EXISTS idx_domains_tenant ON tenant_domains(tenant_id)", ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_domains_domain ON tenant_domains(domain)", ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_domains_status ON tenant_domains(status)", ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_members_tenant ON tenant_members(tenant_id)", ) cursor.execute("CREATE INDEX IF NOT EXISTS idx_members_user ON tenant_members(user_id)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_usage_tenant ON tenant_usage(tenant_id)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_usage_date ON tenant_usage(date)") conn.commit() logger.info("Tenant tables initialized successfully") except (RuntimeError, ValueError, TypeError) as e: logger.error(f"Error initializing tenant tables: {e}") raise finally: conn.close() # ==================== 租户管理 ==================== def create_tenant( self, name: str, owner_id: str, tier: str = "free", description: str | None = None, settings: dict | None = None, ) -> Tenant: """创建新租户""" conn = self._get_connection() try: tenant_id = str(uuid.uuid4()) slug = self._generate_slug(name) # 获取对应层级的资源限制 tier_enum = ( TenantTier(tier) if tier in [t.value for t in TenantTier] else TenantTier.FREE ) resource_limits = self.DEFAULT_LIMITS.get( tier_enum, self.DEFAULT_LIMITS[TenantTier.FREE], ) tenant = Tenant( id=tenant_id, name=name, slug=slug, description=description, tier=tier, status=TenantStatus.PENDING.value, owner_id=owner_id, created_at=datetime.now(), updated_at=datetime.now(), expires_at=None, settings=settings or {}, resource_limits=resource_limits, metadata={}, ) cursor = conn.cursor() cursor.execute( """ INSERT INTO tenants (id, name, slug, description, tier, status, owner_id, created_at, updated_at, expires_at, settings, resource_limits, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( tenant.id, tenant.name, tenant.slug, tenant.description, tenant.tier, tenant.status, tenant.owner_id, tenant.created_at, tenant.updated_at, tenant.expires_at, json.dumps(tenant.settings), json.dumps(tenant.resource_limits), json.dumps(tenant.metadata), ), ) # 自动将所有者添加为成员 self._add_member_internal(conn, tenant_id, owner_id, "", TenantRole.OWNER, None) conn.commit() logger.info(f"Tenant created: {tenant_id} ({name})") return tenant except Exception as e: conn.rollback() logger.error(f"Error creating tenant: {e}") raise finally: conn.close() def get_tenant(self, tenant_id: str) -> Tenant | None: """获取租户信息""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM tenants WHERE id = ?", (tenant_id,)) row = cursor.fetchone() if row: return self._row_to_tenant(row) return None finally: conn.close() def get_tenant_by_slug(self, slug: str) -> Tenant | None: """通过 slug 获取租户""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM tenants WHERE slug = ?", (slug,)) row = cursor.fetchone() if row: return self._row_to_tenant(row) return None finally: conn.close() def get_tenant_by_domain(self, domain: str) -> Tenant | None: """通过自定义域名获取租户""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ SELECT t.* FROM tenants t JOIN tenant_domains d ON t.id = d.tenant_id WHERE d.domain = ? AND d.status = 'verified' """, (domain,), ) row = cursor.fetchone() if row: return self._row_to_tenant(row) return None finally: conn.close() def update_tenant( self, tenant_id: str, name: str | None = None, description: str | None = None, tier: str | None = None, status: str | None = None, settings: dict | None = None, ) -> Tenant | None: """更新租户信息""" conn = self._get_connection() try: tenant = self.get_tenant(tenant_id) if not tenant: return None updates = [] params = [] if name is not None: updates.append("name = ?") params.append(name) if description is not None: updates.append("description = ?") params.append(description) if tier is not None: updates.append("tier = ?") params.append(tier) # 更新资源限制 tier_enum = TenantTier(tier) updates.append("resource_limits = ?") params.append(json.dumps(self.DEFAULT_LIMITS.get(tier_enum, {}))) if status is not None: updates.append("status = ?") params.append(status) if settings is not None: updates.append("settings = ?") params.append(json.dumps(settings)) updates.append("updated_at = ?") params.append(datetime.now()) params.append(tenant_id) cursor = conn.cursor() cursor.execute( f""" UPDATE tenants SET {", ".join(updates)} WHERE id = ? """, params, ) conn.commit() return self.get_tenant(tenant_id) finally: conn.close() def delete_tenant(self, tenant_id: str) -> bool: """删除租户（软删除或硬删除）""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("DELETE FROM tenants WHERE id = ?", (tenant_id,)) conn.commit() return cursor.rowcount > 0 finally: conn.close() def list_tenants( self, status: str | None = None, tier: str | None = None, limit: int = 100, offset: int = 0, ) -> list[Tenant]: """列出租户""" conn = self._get_connection() try: cursor = conn.cursor() query = "SELECT * FROM tenants WHERE 1 = 1" params = [] if status: query += " AND status = ?" params.append(status) if tier: query += " AND tier = ?" params.append(tier) query += " ORDER BY created_at DESC LIMIT ? OFFSET ?" params.extend([limit, offset]) cursor.execute(query, params) rows = cursor.fetchall() return [self._row_to_tenant(row) for row in rows] finally: conn.close() # ==================== 域名管理 ==================== def add_domain( self, tenant_id: str, domain: str, is_primary: bool = False, verification_method: str = "dns", ) -> TenantDomain: """为租户添加自定义域名""" conn = self._get_connection() try: # 验证域名格式 if not self._validate_domain(domain): raise ValueError(f"Invalid domain format: {domain}") # 生成验证令牌 verification_token = self._generate_verification_token(tenant_id, domain) domain_id = str(uuid.uuid4()) tenant_domain = TenantDomain( id=domain_id, tenant_id=tenant_id, domain=domain.lower(), status=DomainStatus.PENDING.value, verification_token=verification_token, verification_method=verification_method, verified_at=None, created_at=datetime.now(), updated_at=datetime.now(), is_primary=is_primary, ssl_enabled=False, ssl_expires_at=None, ) cursor = conn.cursor() # 如果设为主域名，取消其他主域名 if is_primary: cursor.execute( """ UPDATE tenant_domains SET is_primary = 0 WHERE tenant_id = ? """, (tenant_id,), ) cursor.execute( """ INSERT INTO tenant_domains (id, tenant_id, domain, status, verification_token, verification_method, verified_at, created_at, updated_at, is_primary, ssl_enabled, ssl_expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( tenant_domain.id, tenant_domain.tenant_id, tenant_domain.domain, tenant_domain.status, tenant_domain.verification_token, tenant_domain.verification_method, tenant_domain.verified_at, tenant_domain.created_at, tenant_domain.updated_at, int(tenant_domain.is_primary), int(tenant_domain.ssl_enabled), tenant_domain.ssl_expires_at, ), ) conn.commit() logger.info(f"Domain added: {domain} for tenant {tenant_id}") return tenant_domain except Exception as e: conn.rollback() logger.error(f"Error adding domain: {e}") raise finally: conn.close() def verify_domain(self, tenant_id: str, domain_id: str) -> bool: """验证域名所有权""" conn = self._get_connection() try: cursor = conn.cursor() # 获取域名信息 cursor.execute( """ SELECT * FROM tenant_domains WHERE id = ? AND tenant_id = ? """, (domain_id, tenant_id), ) row = cursor.fetchone() if not row: return False domain = row["domain"] token = row["verification_token"] method = row["verification_method"] # 执行验证 is_verified = self._check_domain_verification(domain, token, method) if is_verified: cursor.execute( """ UPDATE tenant_domains SET status = 'verified', verified_at = ?, updated_at = ? WHERE id = ? """, (datetime.now(), datetime.now(), domain_id), ) conn.commit() logger.info(f"Domain verified: {domain}") else: cursor.execute( """ UPDATE tenant_domains SET status = 'failed', updated_at = ? WHERE id = ? """, (datetime.now(), domain_id), ) conn.commit() return is_verified except (RuntimeError, ValueError, TypeError) as e: logger.error(f"Error verifying domain: {e}") return False finally: conn.close() def get_domain_verification_instructions(self, domain_id: str) -> dict[str, Any]: """获取域名验证指导""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM tenant_domains WHERE id = ?", (domain_id,)) row = cursor.fetchone() if not row: return None domain = row["domain"] token = row["verification_token"] return { "domain": domain, "verification_method": row["verification_method"], "dns_record": { "type": "TXT", "name": "_insightflow", "value": f"insightflow-verify = {token}", "ttl": 3600, }, "file_verification": { "url": f"http://{domain}/.well-known/insightflow-verify.txt", "content": token, }, "instructions": [ f"DNS 验证: 添加 TXT 记录 _insightflow.{domain}，值为 insightflow-verify = {token}", f"文件验证: 在网站根目录创建 .well-known/insightflow-verify.txt，内容为 {token}", ], } finally: conn.close() def remove_domain(self, tenant_id: str, domain_id: str) -> bool: """移除域名绑定""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ DELETE FROM tenant_domains WHERE id = ? AND tenant_id = ? """, (domain_id, tenant_id), ) conn.commit() return cursor.rowcount > 0 finally: conn.close() def list_domains(self, tenant_id: str) -> list[TenantDomain]: """列出租户的所有域名""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ SELECT * FROM tenant_domains WHERE tenant_id = ? ORDER BY is_primary DESC, created_at DESC """, (tenant_id,), ) rows = cursor.fetchall() return [self._row_to_domain(row) for row in rows] finally: conn.close() # ==================== 品牌白标管理 ==================== def get_branding(self, tenant_id: str) -> TenantBranding | None: """获取租户品牌配置""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM tenant_branding WHERE tenant_id = ?", (tenant_id,)) row = cursor.fetchone() if row: return self._row_to_branding(row) return None finally: conn.close() def update_branding( self, tenant_id: str, logo_url: str | None = None, favicon_url: str | None = None, primary_color: str | None = None, secondary_color: str | None = None, custom_css: str | None = None, custom_js: str | None = None, login_page_bg: str | None = None, email_template: str | None = None, ) -> TenantBranding: """更新租户品牌配置""" conn = self._get_connection() try: cursor = conn.cursor() # 检查是否已存在 cursor.execute("SELECT id FROM tenant_branding WHERE tenant_id = ?", (tenant_id,)) existing = cursor.fetchone() if existing: # 更新 updates = [] params = [] if logo_url is not None: updates.append("logo_url = ?") params.append(logo_url) if favicon_url is not None: updates.append("favicon_url = ?") params.append(favicon_url) if primary_color is not None: updates.append("primary_color = ?") params.append(primary_color) if secondary_color is not None: updates.append("secondary_color = ?") params.append(secondary_color) if custom_css is not None: updates.append("custom_css = ?") params.append(custom_css) if custom_js is not None: updates.append("custom_js = ?") params.append(custom_js) if login_page_bg is not None: updates.append("login_page_bg = ?") params.append(login_page_bg) if email_template is not None: updates.append("email_template = ?") params.append(email_template) updates.append("updated_at = ?") params.append(datetime.now()) params.append(tenant_id) cursor.execute( f""" UPDATE tenant_branding SET {", ".join(updates)} WHERE tenant_id = ? """, params, ) else: # 创建 branding_id = str(uuid.uuid4()) cursor.execute( """ INSERT INTO tenant_branding (id, tenant_id, logo_url, favicon_url, primary_color, secondary_color, custom_css, custom_js, login_page_bg, email_template, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( branding_id, tenant_id, logo_url, favicon_url, primary_color, secondary_color, custom_css, custom_js, login_page_bg, email_template, datetime.now(), datetime.now(), ), ) conn.commit() return self.get_branding(tenant_id) finally: conn.close() def get_branding_css(self, tenant_id: str) -> str: """生成品牌 CSS""" branding = self.get_branding(tenant_id) if not branding: return "" css = [] if branding.primary_color: css.append(f""" :root {{ --tenant-primary: {branding.primary_color}; --tenant-primary-hover: {self._darken_color(branding.primary_color, 10)}; }} .tenant-primary {{ color: var(--tenant-primary) !important; }} .tenant-bg-primary {{ background-color: var(--tenant-primary) !important; }} .tenant-btn-primary {{ background-color: var(--tenant-primary) !important; border-color: var(--tenant-primary) !important; }} .tenant-btn-primary:hover {{ background-color: var(--tenant-primary-hover) !important; border-color: var(--tenant-primary-hover) !important; }} """) if branding.secondary_color: css.append(f""" :root {{ --tenant-secondary: {branding.secondary_color}; }} .tenant-secondary {{ color: var(--tenant-secondary) !important; }} .tenant-bg-secondary {{ background-color: var(--tenant-secondary) !important; }} """) if branding.custom_css: css.append(branding.custom_css) return "\n".join(css) # ==================== 成员与权限管理 ==================== def invite_member( self, tenant_id: str, email: str, role: str, invited_by: str, permissions: list[str] | None = None, ) -> TenantMember: """邀请成员加入租户""" conn = self._get_connection() try: member_id = str(uuid.uuid4()) # 使用角色默认权限 role_enum = ( TenantRole(role) if role in [r.value for r in TenantRole] else TenantRole.MEMBER ) default_permissions = self.ROLE_PERMISSIONS.get(role_enum, []) final_permissions = permissions or default_permissions member = TenantMember( id=member_id, tenant_id=tenant_id, user_id="pending", # 临时值，待用户接受邀请后更新 email=email, role=role, permissions=final_permissions, invited_by=invited_by, invited_at=datetime.now(), joined_at=None, last_active_at=None, status="pending", ) cursor = conn.cursor() cursor.execute( """ INSERT INTO tenant_members (id, tenant_id, user_id, email, role, permissions, invited_by, invited_at, joined_at, last_active_at, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( member.id, member.tenant_id, member.user_id, member.email, member.role, json.dumps(member.permissions), member.invited_by, member.invited_at, member.joined_at, member.last_active_at, member.status, ), ) conn.commit() logger.info(f"Member invited: {email} to tenant {tenant_id}") return member finally: conn.close() def accept_invitation(self, invitation_id: str, user_id: str) -> bool: """接受邀请""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ UPDATE tenant_members SET user_id = ?, status = 'active', joined_at = ? WHERE id = ? AND status = 'pending' """, (user_id, datetime.now(), invitation_id), ) conn.commit() return cursor.rowcount > 0 finally: conn.close() def remove_member(self, tenant_id: str, member_id: str) -> bool: """移除成员""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ DELETE FROM tenant_members WHERE id = ? AND tenant_id = ? """, (member_id, tenant_id), ) conn.commit() return cursor.rowcount > 0 finally: conn.close() def update_member_role( self, tenant_id: str, member_id: str, role: str, permissions: list[str] | None = None, ) -> bool: """更新成员角色""" conn = self._get_connection() try: role_enum = TenantRole(role) default_permissions = self.ROLE_PERMISSIONS.get(role_enum, []) final_permissions = permissions or default_permissions cursor = conn.cursor() cursor.execute( """ UPDATE tenant_members SET role = ?, permissions = ?, updated_at = ? WHERE id = ? AND tenant_id = ? """, (role, json.dumps(final_permissions), datetime.now(), member_id, tenant_id), ) conn.commit() return cursor.rowcount > 0 finally: conn.close() def list_members(self, tenant_id: str, status: str | None = None) -> list[TenantMember]: """列出租户成员""" conn = self._get_connection() try: cursor = conn.cursor() query = "SELECT * FROM tenant_members WHERE tenant_id = ?" params = [tenant_id] if status: query += " AND status = ?" params.append(status) query += " ORDER BY invited_at DESC" cursor.execute(query, params) rows = cursor.fetchall() return [self._row_to_member(row) for row in rows] finally: conn.close() def check_permission(self, tenant_id: str, user_id: str, resource: str, action: str) -> bool: """检查用户是否有特定权限""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ SELECT role, permissions FROM tenant_members WHERE tenant_id = ? AND user_id = ? AND status = 'active' """, (tenant_id, user_id), ) row = cursor.fetchone() if not row: return False role = row["role"] permissions = json.loads(row["permissions"] or "[]") # 所有者拥有所有权限 if role == TenantRole.OWNER.value: return True # 检查具体权限 required = f"{resource}:{action}" wildcard = f"{resource}:*" return required in permissions or wildcard in permissions or "*" in permissions finally: conn.close() def get_user_tenants(self, user_id: str) -> list[dict[str, Any]]: """获取用户所属的所有租户""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ SELECT t.*, m.role, m.status as member_status FROM tenants t JOIN tenant_members m ON t.id = m.tenant_id WHERE m.user_id = ? AND m.status = 'active' ORDER BY t.created_at DESC """, (user_id,), ) rows = cursor.fetchall() result = [] for row in rows: tenant = self._row_to_tenant(row) result.append( { **asdict(tenant), "member_role": row["role"], "member_status": row["member_status"], }, ) return result finally: conn.close() # ==================== 资源使用统计 ==================== def record_usage( self, tenant_id: str, storage_bytes: int = 0, transcription_seconds: int = 0, api_calls: int = 0, projects_count: int = 0, entities_count: int = 0, members_count: int = 0, ) -> None: """记录资源使用""" conn = self._get_connection() try: today = datetime.now().date() usage_id = str(uuid.uuid4()) cursor = conn.cursor() cursor.execute( """ INSERT INTO tenant_usage (id, tenant_id, date, storage_bytes, transcription_seconds, api_calls, projects_count, entities_count, members_count) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(tenant_id, date) DO UPDATE SET storage_bytes = storage_bytes + excluded.storage_bytes, transcription_seconds = transcription_seconds + excluded.transcription_seconds, api_calls = api_calls + excluded.api_calls, projects_count = MAX(projects_count, excluded.projects_count), entities_count = MAX(entities_count, excluded.entities_count), members_count = MAX(members_count, excluded.members_count) """, ( usage_id, tenant_id, today, storage_bytes, transcription_seconds, api_calls, projects_count, entities_count, members_count, ), ) conn.commit() finally: conn.close() def get_usage_stats( self, tenant_id: str, start_date: datetime | None = None, end_date: datetime | None = None, ) -> dict[str, Any]: """获取使用统计""" conn = self._get_connection() try: cursor = conn.cursor() query = """ SELECT SUM(storage_bytes) as total_storage, SUM(transcription_seconds) as total_transcription, SUM(api_calls) as total_api_calls, MAX(projects_count) as max_projects, MAX(entities_count) as max_entities, MAX(members_count) as max_members FROM tenant_usage WHERE tenant_id = ? """ params = [tenant_id] if start_date: query += " AND date >= ?" params.append(start_date.date()) if end_date: query += " AND date <= ?" params.append(end_date.date()) cursor.execute(query, params) row = cursor.fetchone() # 获取租户限制 tenant = self.get_tenant(tenant_id) limits = tenant.resource_limits if tenant else {} return { "storage_bytes": row["total_storage"] or 0, "storage_mb": (row["total_storage"] or 0) / (1024 * 1024), "transcription_seconds": row["total_transcription"] or 0, "transcription_minutes": (row["total_transcription"] or 0) / 60, "api_calls": row["total_api_calls"] or 0, "projects_count": row["max_projects"] or 0, "entities_count": row["max_entities"] or 0, "members_count": row["max_members"] or 0, "limits": limits, "usage_percentages": { "storage": self._calc_percentage( row["total_storage"] or 0, limits.get("max_storage_mb", 0) * 1024 * 1024, ), "transcription": self._calc_percentage( row["total_transcription"] or 0, limits.get("max_transcription_minutes", 0) * 60, ), "api_calls": self._calc_percentage( row["total_api_calls"] or 0, limits.get("max_api_calls_per_day", 0), ), "projects": self._calc_percentage( row["max_projects"] or 0, limits.get("max_projects", 0), ), "entities": self._calc_percentage( row["max_entities"] or 0, limits.get("max_entities", 0), ), "members": self._calc_percentage( row["max_members"] or 0, limits.get("max_team_members", 0), ), }, } finally: conn.close() def check_resource_limit(self, tenant_id: str, resource_type: str) -> tuple[bool, int, int]: """检查资源是否超限 Returns: (是否允许, 当前使用量, 限制值) """ tenant = self.get_tenant(tenant_id) if not tenant: return False, 0, 0 limits = tenant.resource_limits stats = self.get_usage_stats(tenant_id) resource_map = { "storage": ("storage_mb", stats["storage_mb"]), "transcription": ("max_transcription_minutes", stats["transcription_minutes"]), "api_calls": ("max_api_calls_per_day", stats["api_calls"]), "projects": ("max_projects", stats["projects_count"]), "entities": ("max_entities", stats["entities_count"]), "members": ("max_team_members", stats["members_count"]), } if resource_type not in resource_map: return True, 0, -1 limit_key, current = resource_map[resource_type] limit = limits.get(limit_key, 0) # -1 表示无限制 if limit == -1: return True, current, limit return current < limit, current, limit # ==================== 辅助方法 ==================== def _generate_slug(self, name: str) -> str: """生成 URL 友好的 slug""" # 转换为小写，替换空格为连字符 slug = re.sub(r"[^\w\s-]", "", name.lower()) slug = re.sub(r"[-\s]+", "-", slug) # 检查是否已存在 conn = self._get_connection() try: cursor = conn.cursor() base_slug = slug counter = 1 while True: cursor.execute("SELECT id FROM tenants WHERE slug = ?", (slug,)) if not cursor.fetchone(): break slug = f"{base_slug}-{counter}" counter += 1 return slug finally: conn.close() def _generate_verification_token(self, tenant_id: str, domain: str) -> str: """生成域名验证令牌""" data = f"{tenant_id}:{domain}:{datetime.now().isoformat()}" return hashlib.sha256(data.encode()).hexdigest()[:32] def _validate_domain(self, domain: str) -> bool: """验证域名格式""" pattern = (r"^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0, 61}[a-zA-Z0-9])?\.)*" r"[a-zA-Z0-9](?:[a-zA-Z0-9-]{0, 61}[a-zA-Z0-9])$") return bool(re.match(pattern, domain)) def _check_domain_verification(self, domain: str, token: str, method: str) -> bool: """检查域名验证状态""" # 这里应该实现实际的 DNS 查询或 HTTP 请求 # 简化实现：模拟验证成功 # 实际部署时需要使用 dnspython 或 requests 进行真实验证 if method == "dns": # TODO: 实现 DNS TXT 记录查询 # import dns.resolver # try: # answers = dns.resolver.resolve(f"_insightflow.{domain}", 'TXT') # for rdata in answers: # if token in str(rdata): # return True # except (ImportError, Exception): # pass return True # 模拟成功 elif method == "file": # TODO: 实现 HTTP 文件验证 # import requests # try: # response = requests.get(f"http://{domain}/.well-known/insightflow-verify.txt", timeout = 10) # if response.status_code == 200 and token in response.text: # return True # except (ImportError, Exception): # pass return True # 模拟成功 return False def _darken_color(self, hex_color: str, percent: int) -> str: """加深颜色""" hex_color = hex_color.lstrip("#") r = int(hex_color[0:2], 16) g = int(hex_color[2:4], 16) b = int(hex_color[4:6], 16) r = int(r * (100 - percent) / 100) g = int(g * (100 - percent) / 100) b = int(b * (100 - percent) / 100) return f"#{r:02x}{g:02x}{b:02x}" def _calc_percentage(self, current: int, limit: int) -> float: """计算使用百分比""" if limit <= 0: return 0.0 if limit == 0 else 100.0 return min(100.0, round(current / limit * 100, 2)) def _add_member_internal( self, conn: sqlite3.Connection, tenant_id: str, user_id: str, email: str, role: TenantRole, invited_by: str | None, ) -> None: """内部方法：添加成员""" cursor = conn.cursor() member_id = str(uuid.uuid4()) cursor.execute( """ INSERT OR IGNORE INTO tenant_members (id, tenant_id, user_id, email, role, permissions, invited_by, invited_at, joined_at, last_active_at, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( member_id, tenant_id, user_id, email, role.value, json.dumps(self.ROLE_PERMISSIONS.get(role, [])), invited_by, datetime.now(), datetime.now(), datetime.now(), "active", ), ) def _row_to_tenant(self, row: sqlite3.Row) -> Tenant: """数据库行转换为 Tenant 对象""" return Tenant( id=row["id"], name=row["name"], slug=row["slug"], description=row["description"], tier=row["tier"], status=row["status"], owner_id=row["owner_id"], created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), expires_at=( datetime.fromisoformat(row["expires_at"]) if row["expires_at"] and isinstance(row["expires_at"], str) else row["expires_at"] ), settings=json.loads(row["settings"] or "{}"), resource_limits=json.loads(row["resource_limits"] or "{}"), metadata=json.loads(row["metadata"] or "{}"), ) def _row_to_domain(self, row: sqlite3.Row) -> TenantDomain: """数据库行转换为 TenantDomain 对象""" return TenantDomain( id=row["id"], tenant_id=row["tenant_id"], domain=row["domain"], status=row["status"], verification_token=row["verification_token"], verification_method=row["verification_method"], verified_at=( datetime.fromisoformat(row["verified_at"]) if row["verified_at"] and isinstance(row["verified_at"], str) else row["verified_at"] ), created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), is_primary=bool(row["is_primary"]), ssl_enabled=bool(row["ssl_enabled"]), ssl_expires_at=( datetime.fromisoformat(row["ssl_expires_at"]) if row["ssl_expires_at"] and isinstance(row["ssl_expires_at"], str) else row["ssl_expires_at"] ), ) def _row_to_branding(self, row: sqlite3.Row) -> TenantBranding: """数据库行转换为 TenantBranding 对象""" return TenantBranding( id=row["id"], tenant_id=row["tenant_id"], logo_url=row["logo_url"], favicon_url=row["favicon_url"], primary_color=row["primary_color"], secondary_color=row["secondary_color"], custom_css=row["custom_css"], custom_js=row["custom_js"], login_page_bg=row["login_page_bg"], email_template=row["email_template"], created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), ) def _row_to_member(self, row: sqlite3.Row) -> TenantMember: """数据库行转换为 TenantMember 对象""" return TenantMember( id=row["id"], tenant_id=row["tenant_id"], user_id=row["user_id"], email=row["email"], role=row["role"], permissions=json.loads(row["permissions"] or "[]"), invited_by=row["invited_by"], invited_at=( datetime.fromisoformat(row["invited_at"]) if isinstance(row["invited_at"], str) else row["invited_at"] ), joined_at=( datetime.fromisoformat(row["joined_at"]) if row["joined_at"] and isinstance(row["joined_at"], str) else row["joined_at"] ), last_active_at=( datetime.fromisoformat(row["last_active_at"]) if row["last_active_at"] and isinstance(row["last_active_at"], str) else row["last_active_at"] ), status=row["status"], ) # ==================== 租户上下文管理 ==================== class TenantContext: """租户上下文管理器 - 用于请求级别的租户隔离""" _current_tenant_id: str | None = None _current_user_id: str | None = None @classmethod def set_current_tenant(cls, tenant_id: str) -> None: """设置当前租户上下文""" cls._current_tenant_id = tenant_id @classmethod def get_current_tenant(cls) -> str | None: """获取当前租户ID""" return cls._current_tenant_id @classmethod def set_current_user(cls, user_id: str) -> None: """设置当前用户""" cls._current_user_id = user_id @classmethod def get_current_user(cls) -> str | None: """获取当前用户ID""" return cls._current_user_id @classmethod def clear(cls) -> None: """清除上下文""" cls._current_tenant_id = None cls._current_user_id = None # 全局租户管理器实例 tenant_manager = None def get_tenant_manager(db_path: str = "insightflow.db") -> TenantManager: """获取租户管理器实例（单例模式）""" global tenant_manager if tenant_manager is None: tenant_manager = TenantManager(db_path) return tenant_manager