import datetime import hashlib import secrets import uuid from typing import List, Optional from sqlalchemy.orm import Session from app.config.default_ontology_initializer import DefaultOntologyInitializer from app.core.config import settings from app.core.error_codes import BizCode from app.core.exceptions import BusinessException, PermissionDeniedException from app.core.logging_config import get_business_logger from app.models.user_model import User from app.models.workspace_model import ( InviteStatus, Workspace, WorkspaceMember, WorkspaceRole, ) from app.repositories import workspace_repository from app.repositories.workspace_invite_repository import WorkspaceInviteRepository from app.schemas.workspace_schema import ( InviteAcceptRequest, InviteValidateResponse, WorkspaceCreate, WorkspaceInviteCreate, WorkspaceInviteResponse, WorkspaceMemberUpdate, WorkspaceModelsUpdate, WorkspaceUpdate, ) # 获取业务逻辑专用日志器 business_logger = get_business_logger() def switch_workspace( db: Session, workspace_id: uuid.UUID, user: User, ): """切换工作空间""" business_logger.debug(f"用户 {user.username} 请求切换工作空间为 {workspace_id}") # 检查用户是否为成员或超级管理员 _check_workspace_member_permission(db, workspace_id, user) # 更新当前用户的工作空间上下文 try: user.current_workspace_id = workspace_id db.commit() business_logger.info(f"用户 {user.username} 成功切换工作空间为 {workspace_id}") return except Exception as e: db.rollback() business_logger.error(f"切换工作空间失败 - 工作空间: {workspace_id}, 错误: {str(e)}") raise BusinessException(f"切换工作空间失败: {str(e)}", BizCode.INTERNAL_ERROR) def delete_workspace_member( db: Session, workspace_id: uuid.UUID, member_id: uuid.UUID, user: User, ): """删除工作空间成员""" business_logger.debug(f"用户 {user.username} 请求删除工作空间 {workspace_id} 的成员 {member_id}") _check_workspace_admin_permission(db, workspace_id, user) workspace_member = workspace_repository.get_member_by_id(db=db, member_id=member_id) if not workspace_member: raise BusinessException(f"工作空间成员 {member_id} 不存在", BizCode.WORKSPACE_NOT_FOUND) if workspace_member.workspace_id != workspace_id: raise BusinessException(f"工作空间成员 {member_id} 不存在于工作空间 {workspace_id}", BizCode.WORKSPACE_NOT_FOUND) try: workspace_member.is_active = False workspace_member.user.current_workspace_id = None db.commit() business_logger.info(f"用户 {user.username} 成功删除工作空间 {workspace_id} 的成员 {member_id}") except Exception as e: db.rollback() business_logger.error(f"删除工作空间成员失败 - 工作空间: {workspace_id}, 成员: {member_id}, 错误: {str(e)}") raise BusinessException(f"删除工作空间成员失败: {str(e)}", BizCode.INTERNAL_ERROR) def get_user_workspaces(db: Session, user: User) -> List[Workspace]: """获取当前用户参与的所有工作空间 For neo4j storage type workspaces, ensures each has a default memory config. If a workspace is missing a default config, one will be created automatically. Args: db: Database session user: Current user Returns: List[Workspace]: List of workspaces the user belongs to """ business_logger.debug(f"获取用户工作空间列表: {user.username} (ID: {user.id})") workspaces = workspace_repository.get_workspaces_by_user(db=db, user_id=user.id) # Ensure each neo4j workspace has a default memory config for workspace in workspaces: if workspace.storage_type == 'neo4j': _ensure_default_memory_config(db, workspace) _ensure_default_ontology_scenes(db, workspace) business_logger.info(f"用户 {user.username} 的工作空间数量: {len(workspaces)}") return workspaces def _create_workspace_only( db: Session, workspace: WorkspaceCreate, owner: User ) -> Workspace: business_logger.debug(f"创建工作空间: {workspace.name}, 创建者: {owner.username}") try: # Create the workspace without adding any members business_logger.debug(f"创建工作空间: {workspace.name}") db_workspace = workspace_repository.create_workspace( db=db, workspace=workspace, tenant_id=owner.tenant_id ) business_logger.info(f"工作空间创建成功: {db_workspace.name} (ID: {db_workspace.id}), 创建者: {owner.username}") return db_workspace except Exception as e: business_logger.error(f"创建工作空间失败: {workspace.name} - {str(e)}") raise def create_workspace( db: Session, workspace: WorkspaceCreate, user: User, language: str = "zh" ) -> Workspace: business_logger.info( f"创建工作空间: {workspace.name}, 创建者: {user.username}, " f"storage_type: {workspace.storage_type}" ) if workspace_repository.get_workspaces_by_name(db=db, name=workspace.name, tenant_id=user.tenant_id): raise BusinessException( message="同名工作空间已存在", code=BizCode.RESOURCE_ALREADY_EXISTS ) llm = workspace.llm embedding = workspace.embedding rerank = workspace.rerank try: # Create the workspace without adding any members business_logger.debug(f"创建工作空间: {workspace.name}") db_workspace = workspace_repository.create_workspace( db=db, workspace=workspace, tenant_id=user.tenant_id ) business_logger.info(f"工作空间创建成功: {db_workspace.name} (ID: {db_workspace.id}), 创建者: {user.username}") db.flush() # 使用 flush 而不是 commit，获取 ID 但不提交事务 db.refresh(db_workspace) # Initialize default ontology scenes for the workspace (先创建本体场景) default_scene_id = None default_scene_name = None try: initializer = DefaultOntologyInitializer(db) success, error_msg = initializer.initialize_default_scenes( db_workspace.id, language=language ) if success: business_logger.info( f"为工作空间 {db_workspace.id} 创建默认本体场景成功 (language={language})" ) # 获取默认场景ID，优先使用"在线教育"场景，如果不存在则使用"情感陪伴"场景 from app.repositories.ontology_scene_repository import OntologySceneRepository from app.config.default_ontology_config import ( ONLINE_EDUCATION_SCENE, EMOTIONAL_COMPANION_SCENE, get_scene_name ) scene_repo = OntologySceneRepository(db) # 优先尝试获取教育场景 education_scene_name = get_scene_name(ONLINE_EDUCATION_SCENE, language) education_scene = scene_repo.get_by_name(education_scene_name, db_workspace.id) if education_scene: default_scene_id = education_scene.scene_id default_scene_name = education_scene.scene_name business_logger.info( f"获取到教育场景ID用于默认记忆配置: {default_scene_id} (scene_name={education_scene_name})" ) else: # 如果教育场景不存在，尝试获取情感陪伴场景 companion_scene_name = get_scene_name(EMOTIONAL_COMPANION_SCENE, language) companion_scene = scene_repo.get_by_name(companion_scene_name, db_workspace.id) if companion_scene: default_scene_id = companion_scene.scene_id default_scene_name = companion_scene.scene_name business_logger.info( f"教育场景不存在，使用情感陪伴场景ID用于默认记忆配置: {default_scene_id} (scene_name={companion_scene_name})" ) else: business_logger.warning( f"未找到任何默认场景 (education={education_scene_name}, companion={companion_scene_name})" ) else: business_logger.warning( f"为工作空间 {db_workspace.id} 创建默认本体场景失败: {error_msg} (language={language})" ) except Exception as ontology_error: business_logger.error( f"为工作空间 {db_workspace.id} 创建默认本体场景异常: {str(ontology_error)} (language={language})" ) # Don't fail workspace creation if default ontology initialization fails # The workspace can still function without default ontology scenes # Create default memory config for the workspace (only for neo4j storage types) # 将默认场景ID（教育场景或情感陪伴场景）关联到记忆配置 if workspace.storage_type == 'neo4j': try: _create_default_memory_config( db=db, workspace_id=db_workspace.id, workspace_name=db_workspace.name, llm_id=llm, embedding_id=embedding, rerank_id=rerank, scene_id=default_scene_id, # 传入默认场景ID（优先教育场景，其次情感陪伴场景） pruning_scene_name=default_scene_name, # 传入场景名称作为语义剪枝场景值 ) business_logger.info( f"为工作空间 {db_workspace.id} 创建默认记忆配置成功 (scene_id={default_scene_id})" ) except Exception as mc_error: business_logger.error( f"为工作空间 {db_workspace.id} 创建默认记忆配置失败: {str(mc_error)}" ) # Don't fail workspace creation if memory config creation fails # The workspace can still function without a default memory config # 如果 storage_type 是 "rag"，自动创建知识库 if workspace.storage_type == "rag": business_logger.info( f"检测到 storage_type 为 'rag'，开始为工作空间 " f"{db_workspace.id} 创建知识库" ) try: from app.models.knowledge_model import KnowledgeType, PermissionType from app.repositories import knowledge_repository from app.schemas.knowledge_schema import KnowledgeCreate # 创建知识库数据 knowledge_data = KnowledgeCreate( workspace_id=db_workspace.id, created_by=user.id, parent_id=db_workspace.id, name="USER_RAG_MERORY", description=f"工作空间 {workspace.name} 的默认知识库", avatar='', type=KnowledgeType.General, permission_id=PermissionType.Memory, embedding_id=embedding, reranker_id=rerank, llm_id=llm, image2text_id=llm, parser_config={ "layout_recognize": "DeepDOC", "chunk_token_num": 256, "delimiter": "\n", "auto_keywords": 0, "auto_questions": 0, "html4excel": False } ) # 直接使用 repository 创建知识库，避免 service 层的额外逻辑 db_knowledge = knowledge_repository.create_knowledge( db=db, knowledge=knowledge_data ) business_logger.info( f"为工作空间 {db_workspace.id} 自动创建知识库成功: " f"{db_knowledge.name} (ID: {db_knowledge.id})" ) except Exception as kb_error: business_logger.error( f"为工作空间 {db_workspace.id} 创建知识库失败: {str(kb_error)}" ) db.rollback() raise BusinessException( f"工作空间创建成功，但知识库创建失败: {str(kb_error)}", BizCode.INTERNAL_ERROR ) # 统一提交所有更改 db.commit() business_logger.info( f"工作空间 {db_workspace.id} 及相关资源创建完成并已提交" ) return db_workspace except Exception as e: business_logger.error(f"工作空间创建失败: {workspace.name} - {str(e)}") db.rollback() raise def update_workspace( db: Session, workspace_id: uuid.UUID, workspace_in: WorkspaceUpdate, user: User ) -> Workspace: business_logger.info(f"更新工作空间: workspace_id={workspace_id}, 操作者: {user.username}") db_workspace = _check_workspace_admin_permission(db, workspace_id, user) try: # 更新工作空间 business_logger.debug(f"执行工作空间更新: {db_workspace.name} (ID: {workspace_id})") update_data = workspace_in.model_dump(exclude_unset=True) for field, value in update_data.items(): setattr(db_workspace, field, value) db.add(db_workspace) db.commit() db.refresh(db_workspace) business_logger.info(f"工作空间更新成功: {db_workspace.name} (ID: {workspace_id})") return db_workspace except Exception as e: business_logger.error(f"工作空间更新失败: workspace_id={workspace_id} - {str(e)}") db.rollback() raise def get_workspace_members( db: Session, workspace_id: uuid.UUID, user: User ) -> List[WorkspaceMember]: """获取某工作空间的成员列表（关系序列化由模型关系支持）""" business_logger.info(f"获取工作空间成员: workspace_id={workspace_id}, 操作者: {user.username}") # 查找工作空间 business_logger.debug(f"查找工作空间: {workspace_id}") workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) if not workspace: business_logger.warning(f"工作空间不存在: {workspace_id}") raise BusinessException( message="Workspace not found", code=BizCode.WORKSPACE_NOT_FOUND ) # 权限检查：工作空间成员或超级管理员可以查看成员列表 from app.core.permissions import Action, Resource, Subject, permission_service member = workspace_repository.get_member_in_workspace( db=db, user_id=user.id, workspace_id=workspace_id ) workspace_memberships = {workspace_id} if member else set() subject = Subject.from_user(user, workspace_memberships=workspace_memberships) resource = Resource.from_workspace(workspace) try: permission_service.require_permission( subject, Action.READ, resource, error_message=f"用户 {user.username} 没有查看工作空间 {workspace_id} 成员列表的权限" ) except PermissionDeniedException as e: business_logger.warning( f"权限不足: 用户 {user.username} 尝试获取工作空间 {workspace_id} 成员列表" ) raise BusinessException(str(e), BizCode.WORKSPACE_ACCESS_DENIED) # 查询成员并预加载 user/workspace 关系 members = workspace_repository.get_members_by_workspace(db=db, workspace_id=workspace_id) business_logger.info(f"工作空间成员数量: {len(members)} - workspace_id={workspace_id}") return members # ==================== 邀请相关服务方法 ==================== def _generate_invite_token() -> tuple[str, str]: """生成邀请令牌和其哈希值 Returns: tuple: (原始令牌, 令牌哈希) """ # 生成32字节的随机令牌 token = secrets.token_urlsafe(32) # 生成令牌的SHA256哈希 token_hash = hashlib.sha256(token.encode()).hexdigest() return token, token_hash def _check_workspace_member_permission(db: Session, workspace_id: uuid.UUID, user: User) -> Workspace | None: """检查用户是否为工作空间成员或超级管理员（使用统一权限服务）""" # 获取工作空间信息 db_workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) if not db_workspace: raise BusinessException( message="Workspace not found", code=BizCode.WORKSPACE_NOT_FOUND ) # 使用统一权限服务检查访问权限 from app.core.permissions import Action, Resource, Subject, permission_service # 获取用户的工作空间成员关系 member = workspace_repository.get_member_in_workspace( db=db, user_id=user.id, workspace_id=workspace_id ) # 任何成员都有访问权限 workspace_memberships = {workspace_id} if member else set() subject = Subject.from_user(user, workspace_memberships=workspace_memberships) resource = Resource.from_workspace(db_workspace) try: permission_service.require_permission( subject, Action.READ, resource, error_message=f"用户 {user.username} 不是工作空间 {workspace_id} 的成员" ) business_logger.debug(f"用户 {user.username} 是工作空间 {workspace_id} 的成员或超级管理员") except PermissionDeniedException as e: business_logger.warning(f"权限不足: 用户 {user.username} 尝试访问工作空间 {workspace_id}") raise BusinessException(str(e), BizCode.WORKSPACE_NO_ACCESS) return db_workspace def _check_workspace_admin_permission(db: Session, workspace_id: uuid.UUID, user: User) -> Workspace | None: """检查用户是否有工作空间管理员权限（使用统一权限服务）""" # 获取工作空间信息 db_workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) if not db_workspace: raise BusinessException( message="Workspace not found", code=BizCode.WORKSPACE_NOT_FOUND ) # 使用统一权限服务检查管理权限 from app.core.permissions import Action, Resource, Subject, permission_service # 获取用户的工作空间成员关系 member = workspace_repository.get_member_in_workspace( db=db, user_id=user.id, workspace_id=workspace_id ) # 只有 manager 才有管理权限 workspace_memberships = {workspace_id} if (member and member.role == WorkspaceRole.manager) else set() subject = Subject.from_user(user, workspace_memberships=workspace_memberships) resource = Resource.from_workspace(db_workspace) try: permission_service.require_permission( subject, Action.MANAGE, resource, error_message=f"用户 {user.username} 没有管理工作空间 {workspace_id} 的权限" ) business_logger.debug(f"用户 {user.username} 有权限管理工作空间 {workspace_id}") except PermissionDeniedException as e: business_logger.warning(f"权限不足: 用户 {user.username} 尝试管理工作空间 {workspace_id}") raise BusinessException(str(e), BizCode.WORKSPACE_ACCESS_DENIED) return db_workspace def create_workspace_invite( db: Session, workspace_id: uuid.UUID, invite_data: WorkspaceInviteCreate, user: User ) -> WorkspaceInviteResponse: """创建工作空间邀请""" business_logger.info( f"创建工作空间邀请: workspace_id={workspace_id}, email={invite_data.email}, 创建者: {user.username}") try: # 检查权限 _check_workspace_admin_permission(db, workspace_id, user) # if settings.ENABLE_SINGLE_WORKSPACE: # 检查被邀请用户是否已经在工作空间中 from app.repositories import user_repository invited_user = user_repository.get_user_by_email(db, invite_data.email) if invited_user: # 用户存在，检查是否已经是工作空间成员 existing_member = workspace_repository.get_member_in_workspace( db=db, user_id=invited_user.id, workspace_id=workspace_id ) if existing_member: business_logger.warning(f"用户 {invite_data.email} 已经是工作空间成员") raise BusinessException("该用户已经是工作空间成员", BizCode.RESOURCE_ALREADY_EXISTS) # 检查是否已有待处理的邀请 invite_repo = WorkspaceInviteRepository(db) existing_invite = invite_repo.get_pending_invite_by_email_and_workspace( email=invite_data.email, workspace_id=workspace_id ) invite_token = None if existing_invite: business_logger.info(f"邮箱 {invite_data.email} 在工作空间 {workspace_id} 已有待处理邀请，返回现有邀请") # 生成新的邀请链接（重新生成令牌） token, token_hash = _generate_invite_token() existing_invite.token_hash = token_hash existing_invite.updated_at = datetime.datetime.now() db.commit() db.refresh(existing_invite) invite_token = token else: # 生成邀请令牌 token, token_hash = _generate_invite_token() # 创建邀请 db_invite = invite_repo.create_invite( workspace_id=workspace_id, invite_data=invite_data, token_hash=token_hash, created_by_user_id=user.id ) db.commit() db.refresh(db_invite) invite_token = token invite_obj = existing_invite or db_invite business_logger.info(f"工作空间邀请创建成功: invite_id={invite_obj.id}, email={invite_data.email}") # 构造响应 response = WorkspaceInviteResponse.model_validate(invite_obj) response.invite_token = invite_token return response except Exception as e: db.rollback() business_logger.error( f"创建工作空间邀请失败: workspace_id={workspace_id}, email={invite_data.email} - {str(e)}") raise def get_workspace_invites( db: Session, workspace_id: uuid.UUID, user: User, status: Optional[InviteStatus] = None, limit: int = 50, offset: int = 0 ) -> List[WorkspaceInviteResponse]: """获取工作空间邀请列表""" business_logger.info(f"获取工作空间邀请列表: workspace_id={workspace_id}, 操作者: {user.username}") # 检查工作空间是否存在 workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) if not workspace: raise BusinessException("工作空间不存在", BizCode.WORKSPACE_NOT_FOUND) # 检查权限 _check_workspace_admin_permission(db, workspace_id, user) # 获取邀请列表 invite_repo = WorkspaceInviteRepository(db) invites = invite_repo.get_workspace_invites( workspace_id=workspace_id, status=status, limit=limit, offset=offset ) return [WorkspaceInviteResponse.model_validate(invite) for invite in invites] def validate_invite_token(db: Session, token: str) -> InviteValidateResponse: """验证邀请令牌""" business_logger.info("验证邀请令牌") # 生成令牌哈希 token_hash = hashlib.sha256(token.encode()).hexdigest() # 查找邀请 invite_repo = WorkspaceInviteRepository(db) invite = invite_repo.get_invite_by_token_hash(token_hash) if not invite: business_logger.warning("邀请令牌无效") raise BusinessException("邀请令牌无效", BizCode.WORKSPACE_INVITE_NOT_FOUND) # 检查邀请状态和过期时间 now = datetime.datetime.now() is_expired = invite.expires_at < now or invite.status != InviteStatus.pending is_valid = not is_expired # 获取工作空间信息 workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=invite.workspace_id) business_logger.info(f"邀请令牌验证完成: valid={is_valid}, expired={is_expired}") return InviteValidateResponse( workspace_name=workspace.name, workspace_id=invite.workspace_id, email=invite.email, role=WorkspaceRole(invite.role), is_expired=is_expired, is_valid=is_valid ) def accept_workspace_invite( db: Session, accept_request: InviteAcceptRequest, user: User ) -> dict: """接受工作空间邀请""" business_logger.info(f"接受工作空间邀请: 用户 {user.username}") try: from app.core.config import settings # 生成令牌哈希 token_hash = hashlib.sha256(accept_request.token.encode()).hexdigest() # 查找邀请 invite_repo = WorkspaceInviteRepository(db) invite = invite_repo.get_invite_by_token_hash(token_hash) if not invite: business_logger.warning("邀请令牌无效") raise BusinessException("邀请令牌无效", BizCode.WORKSPACE_INVITE_NOT_FOUND) # 检查邀请状态 if invite.status != InviteStatus.pending: business_logger.warning(f"邀请已被处理: status={invite.status}") raise BusinessException(f"邀请已被{invite.status}", BizCode.WORKSPACE_INVITE_INVALID) # 检查过期时间 now = datetime.datetime.now() if invite.expires_at < now: business_logger.warning("邀请已过期") # 标记为过期 invite_repo.update_invite_status(invite.id, InviteStatus.expired) raise BusinessException("邀请已过期", BizCode.WORKSPACE_INVITE_EXPIRED) # 检查邮箱是否匹配 if invite.email != user.email: business_logger.warning(f"邮箱不匹配: invite_email={invite.email}, user_email={user.email}") raise BusinessException("邮箱与邀请邮箱不匹配", BizCode.FORBIDDEN) # 如果启用单工作空间模式，检查用户是否已有工作空间 if settings.ENABLE_SINGLE_WORKSPACE: user_workspaces = workspace_repository.get_workspaces_by_user(db=db, user_id=user.id) if user_workspaces: business_logger.warning(f"单工作空间模式下用户已有工作空间: user={user.username}") raise BusinessException("用户只能加入一个工作空间", BizCode.FORBIDDEN) # 检查用户是否已经是工作空间成员 existing_member = workspace_repository.get_member_in_workspace( db=db, user_id=user.id, workspace_id=invite.workspace_id ) if existing_member: business_logger.info("用户已是工作空间成员，更新邀请状态") invite_repo.update_invite_status( invite.id, InviteStatus.accepted, accepted_at=now ) db.commit() workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=invite.workspace_id) return { "message": "You are already a member of this workspace", "workspace": workspace } # 将角色映射到工作空间角色（现在直接使用相同的角色） workspace_role = invite.role # 添加用户到工作空间 workspace_repository.add_member_to_workspace( db=db, user_id=user.id, workspace_id=invite.workspace_id, role=workspace_role ) # 标记邀请为已接受 invite_repo.update_invite_status( invite.id, InviteStatus.accepted, accepted_at=now ) db.commit() # 获取工作空间信息 workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=invite.workspace_id) business_logger.info( f"用户成功加入工作空间: user={user.username}, workspace={workspace.name}, role={workspace_role}") return { "message": "Successfully joined the workspace", "workspace": workspace, "role": workspace_role } except Exception as e: db.rollback() business_logger.error(f"接受工作空间邀请失败: user={user.username} - {str(e)}") raise def revoke_workspace_invite( db: Session, workspace_id: uuid.UUID, invite_id: uuid.UUID, user: User ) -> dict: """撤销工作空间邀请""" business_logger.info( f"撤销工作空间邀请: workspace_id={workspace_id}, invite_id={invite_id}, 操作者: {user.username}") try: # 检查权限 _check_workspace_admin_permission(db, workspace_id, user) # 撤销邀请 invite_repo = WorkspaceInviteRepository(db) invite = invite_repo.revoke_invite(invite_id) if not invite: business_logger.warning(f"邀请不存在: invite_id={invite_id}") raise BusinessException("邀请不存在", BizCode.WORKSPACE_INVITE_NOT_FOUND) if invite.workspace_id != workspace_id: business_logger.warning(f"邀请不属于指定工作空间: invite_id={invite_id}, workspace_id={workspace_id}") raise BusinessException("邀请不属于指定工作空间", BizCode.BAD_REQUEST) db.commit() business_logger.info(f"工作空间邀请撤销成功: invite_id={invite_id}") return {"message": "邀请撤销成功"} except Exception as e: db.rollback() business_logger.error(f"撤销工作空间邀请失败: invite_id={invite_id} - {str(e)}") raise def update_workspace_member_roles( db: Session, workspace_id: uuid.UUID, updates: List[WorkspaceMemberUpdate], user: User, ) -> List[WorkspaceMember]: """更新工作空间成员角色""" business_logger.info( f"更新工作空间成员角色: workspace_id={workspace_id}, 操作者: {user.username}, 更新数量: {len(updates)}") # 检查管理员权限 _check_workspace_admin_permission(db, workspace_id, user) # 获取所有当前成员 all_members = workspace_repository.get_members_by_workspace(db=db, workspace_id=workspace_id) member_map = {m.id: m for m in all_members} # 验证和业务规则检查 update_ids = set() for upd in updates: # 检查成员是否存在 if upd.id not in member_map: raise BusinessException(f"成员 {upd.id} 不存在于工作空间 {workspace_id}", BizCode.WORKSPACE_MEMBER_NOT_FOUND) member = member_map[upd.id] # 检查成员是否属于该工作空间 if member.workspace_id != workspace_id: raise BusinessException(f"成员 {upd.id} 不属于工作空间 {workspace_id}", BizCode.WORKSPACE_MEMBER_NOT_FOUND) # 不能修改自己的角色 if member.user_id == user.id: raise BusinessException("不能修改自己的角色", BizCode.BAD_REQUEST) update_ids.add(upd.id) # 检查是否至少保留一个 manager current_managers = [m for m in all_members if m.role == WorkspaceRole.manager] managers_after_update = [ m for m in all_members if m.id not in update_ids and m.role == WorkspaceRole.manager ] # 添加更新后会成为 manager 的成员 for upd in updates: if upd.role == WorkspaceRole.manager: managers_after_update.append(member_map[upd.id]) if len(managers_after_update) == 0: raise BusinessException("工作空间至少需要一个管理员", BizCode.BAD_REQUEST) # 执行更新 try: for upd in updates: workspace_repository.update_member_role_by_id( db=db, id=upd.id, role=upd.role, ) business_logger.debug(f"更新成员 {upd.id} 角色为 {upd.role}") db.commit() # 重新获取更新后的成员列表 updated_members = workspace_repository.get_members_by_workspace(db=db, workspace_id=workspace_id) business_logger.info(f"成员角色更新完成: workspace_id={workspace_id}, 更新数量={len(updates)}") return updated_members except Exception as e: db.rollback() business_logger.error(f"更新工作空间成员角色失败: workspace_id={workspace_id} - {str(e)}") raise BusinessException(f"更新成员角色失败: {str(e)}", BizCode.INTERNAL_ERROR) def get_workspace_storage_type( db: Session, workspace_id: uuid.UUID, user: User, ) -> Optional[str]: """获取工作空间的存储类型 Args: db: 数据库会话 workspace_id: 工作空间ID user: 当前用户 Returns: storage_type: 存储类型字符串，如果未设置则返回 None """ business_logger.info(f"用户 {user.username} 请求获取工作空间 {workspace_id} 的存储类型") # 检查用户是否有权限访问该工作空间 _check_workspace_member_permission(db, workspace_id, user) # 查询工作空间 workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) if not workspace: business_logger.error(f"工作空间不存在: workspace_id={workspace_id}") raise BusinessException( code=BizCode.WORKSPACE_NOT_FOUND, message="工作空间不存在" ) business_logger.info(f"成功获取工作空间 {workspace_id} 的存储类型: {workspace.storage_type}") return workspace.storage_type def get_workspace_storage_type_without_auth( db: Session, workspace_id: uuid.UUID, ) -> str: """获取工作空间的存储类型（无需权限验证，用于公开分享等场景） Args: db: 数据库会话 workspace_id: 工作空间ID Returns: storage_type: 存储类型字符串，如果未设置则返回 None """ business_logger.info(f"获取工作空间 {workspace_id} 的存储类型（无权限验证）") # 查询工作空间 workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) if not workspace: business_logger.error(f"工作空间不存在: workspace_id={workspace_id}") raise BusinessException( code=BizCode.WORKSPACE_NOT_FOUND, message="工作空间不存在" ) business_logger.info(f"成功获取工作空间 {workspace_id} 的存储类型: {workspace.storage_type}") return workspace.storage_type def get_workspace_models_configs( db: Session, workspace_id: uuid.UUID, user: User, ) -> Optional[dict]: """获取工作空间的模型配置（llm, embedding, rerank） Args: db: 数据库会话 workspace_id: 工作空间ID user: 当前用户 Returns: dict: 包含 llm, embedding, rerank 的字典，如果工作空间不存在则返回 None """ business_logger.info(f"用户 {user.username} 请求获取工作空间 {workspace_id} 的模型配置") # 检查用户是否有权限访问该工作空间 _check_workspace_member_permission(db, workspace_id, user) # 查询工作空间模型配置 configs = workspace_repository.get_workspace_models_configs(db=db, workspace_id=workspace_id) if configs is None: business_logger.error(f"工作空间不存在: workspace_id={workspace_id}") raise BusinessException( code=BizCode.WORKSPACE_NOT_FOUND, message="工作空间不存在" ) business_logger.info( f"成功获取工作空间 {workspace_id} 的模型配置: " f"llm={configs.get('llm')}, embedding={configs.get('embedding')}, rerank={configs.get('rerank')}" ) return configs def update_workspace_models_configs( db: Session, workspace_id: uuid.UUID, models_update: WorkspaceModelsUpdate, user: User, ) -> Workspace: """更新工作空间的模型配置（llm, embedding, rerank） Args: db: 数据库会话 workspace_id: 工作空间ID models_update: 模型配置更新对象 user: 当前用户 Returns: Workspace: 更新后的工作空间对象 """ business_logger.info(f"用户 {user.username} 请求更新工作空间 {workspace_id} 的模型配置") # 检查用户是否有管理员权限 db_workspace = _check_workspace_admin_permission(db, workspace_id, user) try: if models_update.llm is not None: db_workspace.llm = str(models_update.llm) if models_update.llm else None business_logger.debug(f"更新LLM配置: {models_update.llm}") if models_update.embedding is not None: db_workspace.embedding = str(models_update.embedding) if models_update.embedding else None business_logger.debug(f"更新嵌入模型配置: {models_update.embedding}") if models_update.rerank is not None: db_workspace.rerank = str(models_update.rerank) if models_update.rerank else None business_logger.debug(f"更新重排序模型配置: {models_update.rerank}") db.add(db_workspace) db.commit() db.refresh(db_workspace) business_logger.info( f"工作空间模型配置更新成功: workspace_id={workspace_id}, " f"llm={db_workspace.llm}, embedding={db_workspace.embedding}, rerank={db_workspace.rerank}" ) return db_workspace except Exception as e: business_logger.error(f"工作空间模型配置更新失败: workspace_id={workspace_id} - {str(e)}") db.rollback() raise BusinessException(f"更新模型配置失败: {str(e)}", BizCode.INTERNAL_ERROR) def _fill_workspace_configs_model_defaults( db: Session, workspace: Workspace ) -> None: """Fill empty model fields for all memory configs in a workspace. Updates llm_id, embedding_id, rerank_id, reflection_model_id, and emotion_model_id if they are None, using the corresponding workspace default models. Args: db: Database session workspace: The workspace containing default model settings """ from app.models.memory_config_model import MemoryConfig # Get all configs for this workspace configs = db.query(MemoryConfig).filter( MemoryConfig.workspace_id == workspace.id ).all() if not configs: return # Map of memory_config field -> workspace field model_field_mappings = [ ("llm_id", "llm"), ("embedding_id", "embedding"), ("rerank_id", "rerank"), ("reflection_model_id", "llm"), # reflection uses LLM ("emotion_model_id", "llm"), # emotion uses LLM ] configs_updated = 0 for memory_config in configs: updated_fields = [] for config_field, workspace_field in model_field_mappings: config_value = getattr(memory_config, config_field, None) workspace_value = getattr(workspace, workspace_field, None) if not config_value and workspace_value: setattr(memory_config, config_field, workspace_value) updated_fields.append(config_field) if updated_fields: configs_updated += 1 business_logger.debug( f"Updated memory config {memory_config.config_id} fields: {updated_fields}" ) if configs_updated > 0: try: db.commit() business_logger.info( f"Updated {configs_updated} memory configs in workspace {workspace.id} with default models" ) except Exception as e: db.rollback() business_logger.error( f"Failed to update memory configs in workspace {workspace.id}: {str(e)}" ) def _create_default_memory_config( db: Session, workspace_id: uuid.UUID, workspace_name: str, llm_id: Optional[uuid.UUID] = None, embedding_id: Optional[uuid.UUID] = None, rerank_id: Optional[uuid.UUID] = None, scene_id: Optional[uuid.UUID] = None, pruning_scene_name: Optional[str] = None, ) -> None: """Create a default memory config for a newly created workspace. Args: db: Database session workspace_id: The workspace ID workspace_name: The workspace name (used for config naming) llm_id: Optional LLM model ID embedding_id: Optional embedding model ID rerank_id: Optional rerank model ID scene_id: Optional ontology scene ID (默认关联教育场景) pruning_scene_name: Optional pruning scene name，取自 ontology_scene.scene_name """ from app.models.memory_config_model import MemoryConfig config_id = uuid.uuid4() default_config = MemoryConfig( config_id=config_id, config_name=f"{workspace_name} 默认配置", config_desc="工作空间创建时自动生成的默认记忆配置", workspace_id=workspace_id, llm_id=str(llm_id) if llm_id else None, embedding_id=str(embedding_id) if embedding_id else None, rerank_id=str(rerank_id) if rerank_id else None, scene_id=scene_id, # 关联本体场景ID（默认为"在线教育"场景） pruning_scene=pruning_scene_name, # 语义剪枝场景直接使用 scene_name state=True, # Active by default is_default=True, # Mark as workspace default ) db.add(default_config) db.flush() # 使用 flush 而不是 commit，让调用者统一提交 business_logger.info( "Created default memory config for workspace", extra={ "workspace_id": str(workspace_id), "config_id": str(config_id), "config_name": default_config.config_name, "scene_id": str(scene_id) if scene_id else None, } ) # ==================== 检查配置相关服务 ==================== def _ensure_default_memory_config(db: Session, workspace: Workspace) -> None: """Ensure a workspace has a default memory config, creating one if missing. Also fills empty model fields for all configs in this workspace. Args: db: Database session workspace: The workspace to check """ from app.models.memory_config_model import MemoryConfig # Check if default config exists for this workspace existing_default = db.query(MemoryConfig).filter( MemoryConfig.workspace_id == workspace.id, MemoryConfig.is_default == True ).first() if not existing_default: # No default config exists, create one business_logger.info( f"Workspace {workspace.id} missing default memory config, creating one" ) # 尝试获取默认场景ID，优先教育场景，其次情感陪伴场景 default_scene_id = None try: from app.repositories.ontology_scene_repository import OntologySceneRepository from app.config.default_ontology_config import ( ONLINE_EDUCATION_SCENE, EMOTIONAL_COMPANION_SCENE, get_scene_name ) scene_repo = OntologySceneRepository(db) # 尝试中文和英文场景名称 for language in ["zh", "en"]: # 优先尝试教育场景 education_scene_name = get_scene_name(ONLINE_EDUCATION_SCENE, language) education_scene = scene_repo.get_by_name(education_scene_name, workspace.id) if education_scene: default_scene_id = education_scene.scene_id business_logger.info( f"找到教育场景用于默认记忆配置: scene_id={default_scene_id}, scene_name={education_scene_name}" ) break # 如果教育场景不存在，尝试情感陪伴场景 companion_scene_name = get_scene_name(EMOTIONAL_COMPANION_SCENE, language) companion_scene = scene_repo.get_by_name(companion_scene_name, workspace.id) if companion_scene: default_scene_id = companion_scene.scene_id business_logger.info( f"教育场景不存在，找到情感陪伴场景用于默认记忆配置: scene_id={default_scene_id}, scene_name={companion_scene_name}" ) break except Exception as scene_error: business_logger.warning( f"获取默认场景失败，将创建不关联场景的记忆配置: {str(scene_error)}" ) try: _create_default_memory_config( db=db, workspace_id=workspace.id, workspace_name=workspace.name, llm_id=uuid.UUID(workspace.llm) if workspace.llm else None, embedding_id=uuid.UUID(workspace.embedding) if workspace.embedding else None, rerank_id=uuid.UUID(workspace.rerank) if workspace.rerank else None, scene_id=default_scene_id, # 传入默认场景ID（优先教育场景，其次情感陪伴场景） ) except Exception as e: business_logger.error( f"Failed to create default memory config for workspace {workspace.id}: {str(e)}" ) # Fill empty model fields for ALL configs in this workspace _fill_workspace_configs_model_defaults(db, workspace) def _ensure_default_ontology_scenes(db: Session, workspace: Workspace) -> None: """Ensure a workspace has default ontology scenes, creating them if missing. Checks whether any is_system_default scene exists for the workspace. If not, runs the DefaultOntologyInitializer to create them. Args: db: Database session workspace: The workspace to check """ from app.models.ontology_scene import OntologyScene # 幂等检查：是否已存在系统默认场景 existing = db.query(OntologyScene).filter( OntologyScene.workspace_id == workspace.id, OntologyScene.is_system_default.is_(True) ).first() if existing: return business_logger.info( f"Workspace {workspace.id} missing default ontology scenes, creating them" ) try: initializer = DefaultOntologyInitializer(db) success, error_msg = initializer.initialize_default_scenes( workspace.id, language="zh" ) if success: db.commit() business_logger.info( f"为工作空间 {workspace.id} 补建默认本体场景成功" ) else: business_logger.warning( f"为工作空间 {workspace.id} 补建默认本体场景失败: {error_msg}" ) except Exception as e: db.rollback() business_logger.error( f"为工作空间 {workspace.id} 补建默认本体场景异常: {str(e)}" )