adai/MemoryBear
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[changes] user_alias修改为end_user_info

Browse Source
This commit is contained in:
lanceyq
2026-03-24 17:30:47 +08:00
parent e8d575fd0b
commit db14d40fb3
8 changed files with 257 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
api/app/controllers/user_memory_controllers.py
View File

@@ -23,10 +23,10 @@ from app.services.memory_entity_relationship_service import MemoryEntityService,
from app.schemas.response_schema import ApiResponse
from app.schemas.memory_storage_schema import GenerateCacheRequest
from app.repositories.workspace_repository import WorkspaceRepository
from app.schemas.user_alias_schema import (
UserAliasResponse,
UserAliasCreate,
UserAliasUpdate,
from app.schemas.end_user_info_schema import (
EndUserInfoResponse,
EndUserInfoCreate,
EndUserInfoUpdate,
)
from app.models.end_user_model import EndUser
from app.dependencies import get_current_user
@@ -337,177 +337,177 @@ async def get_community_graph_data_api(
api_logger.error(f"社区图谱查询失败: end_user_id={end_user_id}, error={str(e)}")
return fail(BizCode.INTERNAL_ERROR, "社区图谱查询失败", str(e))
#=======================用户别名及信息接口=======================
#=======================终端用户信息接口=======================
@router.get("/user_alias", response_model=ApiResponse)
async def get_user_alias(
user_alias_id: str,
@router.get("/end_user_info", response_model=ApiResponse)
async def get_end_user_info(
end_user_info_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
) -> dict:
"""
查询用户别名记录
查询终端用户信息记录
根据 user_alias_id 查询单条用户别名记录。
根据 end_user_info_id 查询单条终端用户信息记录。
"""
workspace_id = current_user.current_workspace_id
if workspace_id is None:
api_logger.warning(f"用户 {current_user.username} 尝试查询用户别名但未选择工作空间")
api_logger.warning(f"用户 {current_user.username} 尝试查询终端用户信息但未选择工作空间")
return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
api_logger.info(
f"查询用户别名请求: user_alias_id={user_alias_id}, user={current_user.username}, "
f"查询终端用户信息请求: end_user_info_id={end_user_info_id}, user={current_user.username}, "
f"workspace={workspace_id}"
)
result = user_memory_service.get_user_alias(db, user_alias_id)
result = user_memory_service.get_end_user_info(db, end_user_info_id)
if result["success"]:
api_logger.info(f"成功查询用户别名: user_alias_id={user_alias_id}")
api_logger.info(f"成功查询终端用户信息: end_user_info_id={end_user_info_id}")
return success(data=result["data"], msg="查询成功")
else:
error_msg = result["error"]
api_logger.error(f"查询用户别名失败: user_alias_id={user_alias_id}, error={error_msg}")
api_logger.error(f"查询终端用户信息失败: end_user_info_id={end_user_info_id}, error={error_msg}")
if error_msg == "用户别名记录不存在":
return fail(BizCode.USER_NOT_FOUND, "用户别名记录不存在", error_msg)
elif error_msg == "无效的用户别名记录ID格式":
return fail(BizCode.INVALID_USER_ID, "无效的用户别名记录ID格式", error_msg)
if error_msg == "终端用户信息记录不存在":
return fail(BizCode.USER_NOT_FOUND, "终端用户信息记录不存在", error_msg)
elif error_msg == "无效的终端用户信息记录ID格式":
return fail(BizCode.INVALID_USER_ID, "无效的终端用户信息记录ID格式", error_msg)
else:
return fail(BizCode.INTERNAL_ERROR, "查询用户别名失败", error_msg)
return fail(BizCode.INTERNAL_ERROR, "查询终端用户信息失败", error_msg)
@router.post("/user_alias/create", response_model=ApiResponse)
async def create_user_alias(
alias_create: UserAliasCreate,
@router.post("/end_user_info/create", response_model=ApiResponse)
async def create_end_user_info(
info_create: EndUserInfoCreate,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
) -> dict:
"""
创建用户别名记录
创建终端用户信息记录
为指定用户创建一条新的别名记录，支持多个别名。
为指定用户创建一条新的信息记录，支持多个别名。
"""
workspace_id = current_user.current_workspace_id
end_user_id = alias_create.end_user_id
end_user_id = info_create.end_user_id
if workspace_id is None:
api_logger.warning(f"用户 {current_user.username} 尝试创建别名但未选择工作空间")
api_logger.warning(f"用户 {current_user.username} 尝试创建终端用户信息但未选择工作空间")
return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
api_logger.info(
f"创建用户别名请求: end_user_id={end_user_id}, aliases={alias_create.aliases}, "
f"创建终端用户信息请求: end_user_id={end_user_id}, aliases={info_create.aliases}, "
f"user={current_user.username}, workspace={workspace_id}"
)
result = user_memory_service.create_user_alias(
db, end_user_id, alias_create.other_name, alias_create.aliases, alias_create.meta_data
result = user_memory_service.create_end_user_info(
db, end_user_id, info_create.other_name, info_create.aliases, info_create.meta_data
)
if result["success"]:
api_logger.info(f"成功创建用户别名: end_user_id={end_user_id}")
api_logger.info(f"成功创建终端用户信息: end_user_id={end_user_id}")
return success(data=result["data"], msg="创建成功")
else:
error_msg = result["error"]
api_logger.error(f"用户别名创建失败: end_user_id={end_user_id}, error={error_msg}")
api_logger.error(f"终端用户信息创建失败: end_user_id={end_user_id}, error={error_msg}")
if error_msg == "终端用户不存在":
return fail(BizCode.USER_NOT_FOUND, "终端用户不存在", error_msg)
elif error_msg == "无效的用户ID格式":
return fail(BizCode.INVALID_USER_ID, "无效的用户ID格式", error_msg)
else:
return fail(BizCode.INTERNAL_ERROR, "用户别名创建失败", error_msg)
return fail(BizCode.INTERNAL_ERROR, "终端用户信息创建失败", error_msg)
@router.post("/user_alias/updated", response_model=ApiResponse)
async def update_user_alias(
alias_update: UserAliasUpdate,
@router.post("/end_user_info/updated", response_model=ApiResponse)
async def update_end_user_info(
info_update: EndUserInfoUpdate,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
) -> dict:
"""
更新用户别名记录
更新终端用户信息记录
根据 user_alias_id 更新用户别名记录，支持批量更新多个别名。
根据 end_user_info_id 更新终端用户信息记录，支持批量更新多个别名。
示例请求体：
{
"user_alias_id": "2d4f57d4-639b-47aa-937a-d461bc2c2d53",
"end_user_info_id": "2d4f57d4-639b-47aa-937a-d461bc2c2d53",
"other_name": "张三1",
"aliases": ["小张", "张工"],
"meta_data": {"position": "工程师", "department": "技术部"}
}
"""
workspace_id = current_user.current_workspace_id
user_alias_id = alias_update.user_alias_id
end_user_info_id = info_update.end_user_info_id
if workspace_id is None:
api_logger.warning(f"用户 {current_user.username} 尝试更新用户别名但未选择工作空间")
api_logger.warning(f"用户 {current_user.username} 尝试更新终端用户信息但未选择工作空间")
return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
api_logger.info(
f"更新用户别名请求: user_alias_id={user_alias_id}, user={current_user.username}, "
f"更新终端用户信息请求: end_user_info_id={end_user_info_id}, user={current_user.username}, "
f"workspace={workspace_id}"
)
# 获取更新数据（排除 user_alias_id）
update_data = alias_update.model_dump(exclude_unset=True, exclude={'user_alias_id'})
# 获取更新数据（排除 end_user_info_id）
update_data = info_update.model_dump(exclude_unset=True, exclude={'end_user_info_id'})
result = user_memory_service.update_user_alias(db, user_alias_id, update_data)
result = user_memory_service.update_end_user_info(db, end_user_info_id, update_data)
if result["success"]:
api_logger.info(f"成功更新用户别名: user_alias_id={user_alias_id}")
api_logger.info(f"成功更新终端用户信息: end_user_info_id={end_user_info_id}")
return success(data=result["data"], msg="更新成功")
else:
error_msg = result["error"]
api_logger.error(f"用户别名更新失败: user_alias_id={user_alias_id}, error={error_msg}")
api_logger.error(f"终端用户信息更新失败: end_user_info_id={end_user_info_id}, error={error_msg}")
if error_msg == "用户别名记录不存在":
return fail(BizCode.USER_NOT_FOUND, "用户别名记录不存在", error_msg)
elif error_msg == "无效的用户别名记录ID格式":
return fail(BizCode.INVALID_USER_ID, "无效的用户别名记录ID格式", error_msg)
if error_msg == "终端用户信息记录不存在":
return fail(BizCode.USER_NOT_FOUND, "终端用户信息记录不存在", error_msg)
elif error_msg == "无效的终端用户信息记录ID格式":
return fail(BizCode.INVALID_USER_ID, "无效的终端用户信息记录ID格式", error_msg)
else:
return fail(BizCode.INTERNAL_ERROR, "用户别名更新失败", error_msg)
return fail(BizCode.INTERNAL_ERROR, "终端用户信息更新失败", error_msg)
@router.delete("/user_alias", response_model=ApiResponse)
async def delete_user_alias(
user_alias_id: str,
@router.delete("/end_user_info", response_model=ApiResponse)
async def delete_end_user_info(
end_user_info_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
) -> dict:
"""
删除用户别名记录
删除终端用户信息记录
根据 user_alias_id 删除指定的用户别名记录。
根据 end_user_info_id 删除指定的终端用户信息记录。
"""
workspace_id = current_user.current_workspace_id
if workspace_id is None:
api_logger.warning(f"用户 {current_user.username} 尝试删除别名但未选择工作空间")
api_logger.warning(f"用户 {current_user.username} 尝试删除终端用户信息但未选择工作空间")
return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
api_logger.info(
f"删除用户别名请求: user_alias_id={user_alias_id}, user={current_user.username}, "
f"删除终端用户信息请求: end_user_info_id={end_user_info_id}, user={current_user.username}, "
f"workspace={workspace_id}"
)
result = user_memory_service.delete_user_alias(db, user_alias_id)
result = user_memory_service.delete_end_user_info(db, end_user_info_id)
if result["success"]:
api_logger.info(f"成功删除用户别名: user_alias_id={user_alias_id}")
api_logger.info(f"成功删除终端用户信息: end_user_info_id={end_user_info_id}")
return success(data=result["data"], msg="删除成功")
else:
error_msg = result["error"]
api_logger.error(f"用户别名删除失败: user_alias_id={user_alias_id}, error={error_msg}")
api_logger.error(f"终端用户信息删除失败: end_user_info_id={end_user_info_id}, error={error_msg}")
if error_msg == "用户别名记录不存在":
return fail(BizCode.USER_NOT_FOUND, "用户别名记录不存在", error_msg)
elif error_msg == "无效的用户别名记录ID格式":
return fail(BizCode.INVALID_USER_ID, "无效的用户别名记录ID格式", error_msg)
if error_msg == "终端用户信息记录不存在":
return fail(BizCode.USER_NOT_FOUND, "终端用户信息记录不存在", error_msg)
elif error_msg == "无效的终端用户信息记录ID格式":
return fail(BizCode.INVALID_USER_ID, "无效的终端用户信息记录ID格式", error_msg)
else:
return fail(BizCode.INTERNAL_ERROR, "用户别名删除失败", error_msg)
return fail(BizCode.INTERNAL_ERROR, "终端用户信息删除失败", error_msg)
@router.get("/memory_space/timeline_memories", response_model=ApiResponse)
async def memory_space_timeline_of_shared_memories(

2
api/app/models/__init__.py
View File

@@ -16,7 +16,7 @@ from .agent_app_config_model import AgentConfig
from .app_release_model import AppRelease
from .memory_increment_model import MemoryIncrement
from .end_user_model import EndUser
from .user_alias_model import UserAlias
from .end_user_info_model import EndUserInfo
from .appshare_model import AppShare
from .release_share_model import ReleaseShare
from .conversation_model import Conversation, Message

8
api/app/models/user_alias_model.py → api/app/models/end_user_info_model.py
View File

@@ -8,9 +8,9 @@ from sqlalchemy.orm import relationship
from app.db import Base
class UserAlias(Base):
"""用户别名表 - 存储用户的别名信息"""
__tablename__ = "user_aliases"
class EndUserInfo(Base):
"""终端用户信息表 - 存储用户的别名和扩展信息"""
__tablename__ = "end_user_info"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, nullable=False, index=True)
end_user_id = Column(UUID(as_uuid=True), ForeignKey("end_users.id"), nullable=False, index=True, comment="关联的终端用户ID")
@@ -21,4 +21,4 @@ class UserAlias(Base):
updated_at = Column(DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now, comment="更新时间")
# 与 EndUser 的关系
end_user = relationship("EndUser", back_populates="aliases")
end_user = relationship("EndUser", back_populates="info")

4
api/app/models/end_user_model.py
View File

@@ -59,5 +59,5 @@ class EndUser(Base):
# 与 WorkSpace 的反向关系
workspace = relationship("Workspace", back_populates="end_users")
# 与 UserAlias 的反向关系
aliases = relationship("UserAlias", back_populates="end_user", cascade="all, delete-orphan")
# 与 EndUserInfo 的反向关系
info = relationship("EndUserInfo", back_populates="end_user", cascade="all, delete-orphan")

90
api/app/repositories/end_user_info_repository.py Normal file
View File

@@ -0,0 +1,90 @@
"""
终端用户信息仓储层
"""
import uuid
from typing import List, Optional
from sqlalchemy.orm import Session
from app.models.end_user_info_model import EndUserInfo
from app.core.logging_config import get_logger
logger = get_logger(__name__)
class EndUserInfoRepository:
"""终端用户信息仓储类"""
def __init__(self, db: Session):
self.db = db
def create(self, end_user_id: uuid.UUID, other_name: str, alias: str = None, meta_data: dict = None) -> EndUserInfo:
"""创建终端用户信息"""
end_user_info = EndUserInfo(
end_user_id=end_user_id,
other_name=other_name,
alias=alias,
meta_data=meta_data
)
self.db.add(end_user_info)
self.db.commit()
self.db.refresh(end_user_info)
logger.info(f"创建终端用户信息: end_user_id={end_user_id}, alias={alias}")
return end_user_info
def get_by_id(self, info_id: uuid.UUID) -> Optional[EndUserInfo]:
"""根据ID获取用户信息"""
return self.db.query(EndUserInfo).filter(EndUserInfo.id == info_id).first()
def get_by_end_user_id(self, end_user_id: uuid.UUID) -> List[EndUserInfo]:
"""获取用户的所有信息记录"""
return self.db.query(EndUserInfo).filter(EndUserInfo.end_user_id == end_user_id).all()
def update(self, info_id: uuid.UUID, alias: str = None, meta_data: dict = None) -> Optional[EndUserInfo]:
"""更新用户信息"""
end_user_info = self.get_by_id(info_id)
if end_user_info:
if alias is not None:
end_user_info.alias = alias
if meta_data is not None:
end_user_info.meta_data = meta_data
self.db.commit()
self.db.refresh(end_user_info)
logger.info(f"更新终端用户信息: info_id={info_id}")
return end_user_info
def delete(self, info_id: uuid.UUID) -> bool:
"""删除用户信息"""
end_user_info = self.get_by_id(info_id)
if end_user_info:
self.db.delete(end_user_info)
self.db.commit()
logger.info(f"删除终端用户信息: info_id={info_id}")
return True
return False
def delete_by_end_user_id(self, end_user_id: uuid.UUID) -> int:
"""删除用户的所有信息记录"""
count = self.db.query(EndUserInfo).filter(EndUserInfo.end_user_id == end_user_id).delete()
self.db.commit()
logger.info(f"删除用户所有信息记录: end_user_id={end_user_id}, count={count}")
return count
def batch_create(self, end_user_id: uuid.UUID, other_name: str, aliases: List[str]) -> List[EndUserInfo]:
"""批量创建用户信息"""
end_user_infos = []
for alias in aliases:
if alias and alias.strip():
end_user_info = EndUserInfo(
end_user_id=end_user_id,
other_name=other_name,
alias=alias.strip()
)
self.db.add(end_user_info)
end_user_infos.append(end_user_info)
self.db.commit()
for end_user_info in end_user_infos:
self.db.refresh(end_user_info)
logger.info(f"批量创建终端用户信息: end_user_id={end_user_id}, count={len(end_user_infos)}")
return end_user_infos

90
api/app/repositories/user_alias_repository.py
View File

@@ -1,90 +0,0 @@
"""
用户别名仓储层
"""
import uuid
from typing import List, Optional
from sqlalchemy.orm import Session
from app.models.user_alias_model import UserAlias
from app.core.logging_config import get_logger
logger = get_logger(__name__)
class UserAliasRepository:
"""用户别名仓储类"""
def __init__(self, db: Session):
self.db = db
def create(self, end_user_id: uuid.UUID, other_name: str, alias: str = None, meta_data: dict = None) -> UserAlias:
"""创建用户别名"""
user_alias = UserAlias(
end_user_id=end_user_id,
other_name=other_name,
alias=alias,
meta_data=meta_data
)
self.db.add(user_alias)
self.db.commit()
self.db.refresh(user_alias)
logger.info(f"创建用户别名: end_user_id={end_user_id}, alias={alias}")
return user_alias
def get_by_id(self, alias_id: uuid.UUID) -> Optional[UserAlias]:
"""根据ID获取别名"""
return self.db.query(UserAlias).filter(UserAlias.id == alias_id).first()
def get_by_end_user_id(self, end_user_id: uuid.UUID) -> List[UserAlias]:
"""获取用户的所有别名"""
return self.db.query(UserAlias).filter(UserAlias.end_user_id == end_user_id).all()
def update(self, alias_id: uuid.UUID, alias: str = None, meta_data: dict = None) -> Optional[UserAlias]:
"""更新别名"""
user_alias = self.get_by_id(alias_id)
if user_alias:
if alias is not None:
user_alias.alias = alias
if meta_data is not None:
user_alias.meta_data = meta_data
self.db.commit()
self.db.refresh(user_alias)
logger.info(f"更新用户别名: alias_id={alias_id}")
return user_alias
def delete(self, alias_id: uuid.UUID) -> bool:
"""删除别名"""
user_alias = self.get_by_id(alias_id)
if user_alias:
self.db.delete(user_alias)
self.db.commit()
logger.info(f"删除用户别名: alias_id={alias_id}")
return True
return False
def delete_by_end_user_id(self, end_user_id: uuid.UUID) -> int:
"""删除用户的所有别名"""
count = self.db.query(UserAlias).filter(UserAlias.end_user_id == end_user_id).delete()
self.db.commit()
logger.info(f"删除用户所有别名: end_user_id={end_user_id}, count={count}")
return count
def batch_create(self, end_user_id: uuid.UUID, other_name: str, aliases: List[str]) -> List[UserAlias]:
"""批量创建别名"""
user_aliases = []
for alias in aliases:
if alias and alias.strip():
user_alias = UserAlias(
end_user_id=end_user_id,
other_name=other_name,
alias=alias.strip()
)
self.db.add(user_alias)
user_aliases.append(user_alias)
self.db.commit()
for user_alias in user_aliases:
self.db.refresh(user_alias)
logger.info(f"批量创建用户别名: end_user_id={end_user_id}, count={len(user_aliases)}")
return user_aliases

20
api/app/schemas/user_alias_schema.py → api/app/schemas/end_user_info_schema.py
View File

@@ -5,31 +5,31 @@ from pydantic import BaseModel, Field
from pydantic import ConfigDict
class UserAliasBase(BaseModel):
"""用户别名基础模型"""
class EndUserInfoBase(BaseModel):
"""终端用户信息基础模型"""
other_name: str = Field(description="关联的用户名称")
aliases: Optional[List[str]] = Field(description="用户别名列表", default=None)
meta_data: Optional[Dict[str, Any]] = Field(description="用户相关的扩展信息", default=None)
class UserAliasCreate(UserAliasBase):
"""创建用户别名请求模型"""
class EndUserInfoCreate(EndUserInfoBase):
"""创建终端用户信息请求模型"""
end_user_id: str = Field(description="关联的终端用户ID")
class UserAliasUpdate(BaseModel):
"""更新用户别名请求模型"""
user_alias_id: str = Field(description="用户别名记录ID")
class EndUserInfoUpdate(BaseModel):
"""更新终端用户信息请求模型"""
end_user_info_id: str = Field(description="终端用户信息记录ID")
other_name: Optional[str] = Field(description="用户名称", default=None)
aliases: Optional[List[str]] = Field(description="用户别名列表", default=None)
meta_data: Optional[Dict[str, Any]] = Field(description="用户相关的扩展信息", default=None)
class UserAliasResponse(UserAliasBase):
"""用户别名响应模型"""
class EndUserInfoResponse(EndUserInfoBase):
"""终端用户信息响应模型"""
model_config = ConfigDict(from_attributes=True)
user_alias_id: uuid.UUID = Field(description="用户别名记录ID")
end_user_info_id: uuid.UUID = Field(description="终端用户信息记录ID")
end_user_id: uuid.UUID = Field(description="关联的终端用户ID")
created_at: datetime.datetime = Field(description="创建时间")
updated_at: datetime.datetime = Field(description="更新时间")

166
api/app/services/user_memory_service.py
View File

@@ -362,17 +362,17 @@ class UserMemoryService:
data[key] = UserMemoryService._datetime_to_timestamp(original_value)
return data
# ======================== 用户别名及信息 ========================
def get_user_alias(
def get_end_user_info(
self,
db: Session,
user_alias_id: str
end_user_info_id: str
) -> Dict[str, Any]:
"""
查询单个用户别名记录
查询单个终端用户信息记录
Args:
db: 数据库会话
user_alias_id: 用户别名记录ID (UUID)
end_user_info_id: 终端用户信息记录ID (UUID)
Returns:
{
@@ -382,33 +382,33 @@ class UserMemoryService:
}
"""
try:
from app.models.user_alias_model import UserAlias
from app.models.end_user_info_model import EndUserInfo
# 转换为UUID并查询
alias_uuid = uuid.UUID(user_alias_id)
user_alias_record = db.query(UserAlias).filter(UserAlias.id == alias_uuid).first()
info_uuid = uuid.UUID(end_user_info_id)
end_user_info_record = db.query(EndUserInfo).filter(EndUserInfo.id == info_uuid).first()
if not user_alias_record:
logger.warning(f"用户别名记录不存在: user_alias_id={user_alias_id}")
if not end_user_info_record:
logger.warning(f"终端用户信息记录不存在: end_user_info_id={end_user_info_id}")
return {
"success": False,
"data": None,
"error": "用户别名记录不存在"
"error": "终端用户信息记录不存在"
}
# 构建响应数据
from app.schemas.user_alias_schema import UserAliasResponse
response_data = UserAliasResponse(
user_alias_id=user_alias_record.id,
end_user_id=user_alias_record.end_user_id,
other_name=user_alias_record.other_name,
aliases=user_alias_record.aliases,
meta_data=user_alias_record.meta_data,
created_at=user_alias_record.created_at,
updated_at=user_alias_record.updated_at
from app.schemas.end_user_info_schema import EndUserInfoResponse
response_data = EndUserInfoResponse(
end_user_info_id=end_user_info_record.id,
end_user_id=end_user_info_record.end_user_id,
other_name=end_user_info_record.other_name,
aliases=end_user_info_record.aliases,
meta_data=end_user_info_record.meta_data,
created_at=end_user_info_record.created_at,
updated_at=end_user_info_record.updated_at
)
logger.info(f"成功查询用户别名记录: user_alias_id={user_alias_id}")
logger.info(f"成功查询终端用户信息记录: end_user_info_id={end_user_info_id}")
return {
"success": True,
@@ -417,21 +417,21 @@ class UserMemoryService:
}
except ValueError:
logger.error(f"无效的 user_alias_id 格式: {user_alias_id}")
logger.error(f"无效的 end_user_info_id 格式: {end_user_info_id}")
return {
"success": False,
"data": None,
"error": "无效的用户别名记录ID格式"
"error": "无效的终端用户信息记录ID格式"
}
except Exception as e:
logger.error(f"查询用户别名记录失败: user_alias_id={user_alias_id}, error={str(e)}")
logger.error(f"查询终端用户信息记录失败: end_user_info_id={end_user_info_id}, error={str(e)}")
return {
"success": False,
"data": None,
"error": str(e)
}
def create_user_alias(
def create_end_user_info(
self,
db: Session,
end_user_id: str,
@@ -440,7 +440,7 @@ class UserMemoryService:
meta_data: dict = None
) -> Dict[str, Any]:
"""
创建用户别名记录
创建终端用户信息记录
Args:
db: 数据库会话
@@ -457,7 +457,7 @@ class UserMemoryService:
}
"""
try:
from app.models.user_alias_model import UserAlias
from app.models.end_user_info_model import EndUserInfo
from app.repositories.end_user_repository import EndUserRepository
# 转换为UUID并查询用户
@@ -473,30 +473,30 @@ class UserMemoryService:
"error": "终端用户不存在"
}
# 创建新的别名记录
new_alias = UserAlias(
# 创建新的用户信息记录
new_info = EndUserInfo(
end_user_id=user_uuid,
other_name=other_name,
aliases=aliases,
meta_data=meta_data
)
db.add(new_alias)
db.add(new_info)
db.commit()
db.refresh(new_alias)
db.refresh(new_info)
# 构建响应数据
from app.schemas.user_alias_schema import UserAliasResponse
response_data = UserAliasResponse(
user_alias_id=new_alias.id,
end_user_id=new_alias.end_user_id,
other_name=new_alias.other_name,
aliases=new_alias.aliases,
meta_data=new_alias.meta_data,
created_at=new_alias.created_at,
updated_at=new_alias.updated_at
from app.schemas.end_user_info_schema import EndUserInfoResponse
response_data = EndUserInfoResponse(
end_user_info_id=new_info.id,
end_user_id=new_info.end_user_id,
other_name=new_info.other_name,
aliases=new_info.aliases,
meta_data=new_info.meta_data,
created_at=new_info.created_at,
updated_at=new_info.updated_at
)
logger.info(f"成功创建用户别名记录: end_user_id={end_user_id}")
logger.info(f"成功创建终端用户信息记录: end_user_id={end_user_id}")
return {
"success": True,
@@ -513,25 +513,25 @@ class UserMemoryService:
}
except Exception as e:
db.rollback()
logger.error(f"创建用户别名记录失败: end_user_id={end_user_id}, error={str(e)}")
logger.error(f"创建终端用户信息记录失败: end_user_id={end_user_id}, error={str(e)}")
return {
"success": False,
"data": None,
"error": str(e)
}
def update_user_alias(
def update_end_user_info(
self,
db: Session,
user_alias_id: str,
end_user_info_id: str,
update_data: Dict[str, Any]
) -> Dict[str, Any]:
"""
更新用户别名记录
更新终端用户信息记录
Args:
db: 数据库会话
user_alias_id: 用户别名记录ID (UUID)
end_user_info_id: 终端用户信息记录ID (UUID)
update_data: 更新数据字典
Returns:
@@ -542,18 +542,18 @@ class UserMemoryService:
}
"""
try:
from app.models.user_alias_model import UserAlias
from app.models.end_user_info_model import EndUserInfo
# 转换为UUID并查询
alias_uuid = uuid.UUID(user_alias_id)
user_alias_record = db.query(UserAlias).filter(UserAlias.id == alias_uuid).first()
info_uuid = uuid.UUID(end_user_info_id)
end_user_info_record = db.query(EndUserInfo).filter(EndUserInfo.id == info_uuid).first()
if not user_alias_record:
logger.warning(f"用户别名记录不存在: user_alias_id={user_alias_id}")
if not end_user_info_record:
logger.warning(f"终端用户信息记录不存在: end_user_info_id={end_user_info_id}")
return {
"success": False,
"data": None,
"error": "用户别名记录不存在"
"error": "终端用户信息记录不存在"
}
# 定义允许更新的字段白名单
@@ -562,28 +562,28 @@ class UserMemoryService:
# 更新字段（仅允许白名单中的字段）
for field, value in update_data.items():
if field in allowed_fields:
setattr(user_alias_record, field, value)
setattr(end_user_info_record, field, value)
# 更新时间戳
user_alias_record.updated_at = datetime.now()
end_user_info_record.updated_at = datetime.now()
# 提交更改
db.commit()
db.refresh(user_alias_record)
db.refresh(end_user_info_record)
# 构建响应数据
from app.schemas.user_alias_schema import UserAliasResponse
response_data = UserAliasResponse(
user_alias_id=user_alias_record.id,
end_user_id=user_alias_record.end_user_id,
other_name=user_alias_record.other_name,
aliases=user_alias_record.aliases,
meta_data=user_alias_record.meta_data,
created_at=user_alias_record.created_at,
updated_at=user_alias_record.updated_at
from app.schemas.end_user_info_schema import EndUserInfoResponse
response_data = EndUserInfoResponse(
end_user_info_id=end_user_info_record.id,
end_user_id=end_user_info_record.end_user_id,
other_name=end_user_info_record.other_name,
aliases=end_user_info_record.aliases,
meta_data=end_user_info_record.meta_data,
created_at=end_user_info_record.created_at,
updated_at=end_user_info_record.updated_at
)
logger.info(f"成功更新用户别名记录: user_alias_id={user_alias_id}, updated_fields={list(update_data.keys())}")
logger.info(f"成功更新终端用户信息记录: end_user_info_id={end_user_info_id}, updated_fields={list(update_data.keys())}")
return {
"success": True,
@@ -592,32 +592,32 @@ class UserMemoryService:
}
except ValueError:
logger.error(f"无效的 user_alias_id 格式: {user_alias_id}")
logger.error(f"无效的 end_user_info_id 格式: {end_user_info_id}")
return {
"success": False,
"data": None,
"error": "无效的用户别名记录ID格式"
"error": "无效的终端用户信息记录ID格式"
}
except Exception as e:
db.rollback()
logger.error(f"更新用户别名记录失败: user_alias_id={user_alias_id}, error={str(e)}")
logger.error(f"更新终端用户信息记录失败: end_user_info_id={end_user_info_id}, error={str(e)}")
return {
"success": False,
"data": None,
"error": str(e)
}
def delete_user_alias(
def delete_end_user_info(
self,
db: Session,
user_alias_id: str
end_user_info_id: str
) -> Dict[str, Any]:
"""
删除用户别名记录
删除终端用户信息记录
Args:
db: 数据库会话
user_alias_id: 用户别名记录ID (UUID)
end_user_info_id: 终端用户信息记录ID (UUID)
Returns:
{
@@ -627,42 +627,42 @@ class UserMemoryService:
}
"""
try:
from app.models.user_alias_model import UserAlias
from app.models.end_user_info_model import EndUserInfo
# 转换为UUID并查询
alias_uuid = uuid.UUID(user_alias_id)
user_alias_record = db.query(UserAlias).filter(UserAlias.id == alias_uuid).first()
info_uuid = uuid.UUID(end_user_info_id)
end_user_info_record = db.query(EndUserInfo).filter(EndUserInfo.id == info_uuid).first()
if not user_alias_record:
logger.warning(f"用户别名记录不存在: user_alias_id={user_alias_id}")
if not end_user_info_record:
logger.warning(f"终端用户信息记录不存在: end_user_info_id={end_user_info_id}")
return {
"success": False,
"data": None,
"error": "用户别名记录不存在"
"error": "终端用户信息记录不存在"
}
# 删除记录
db.delete(user_alias_record)
db.delete(end_user_info_record)
db.commit()
logger.info(f"成功删除用户别名记录: user_alias_id={user_alias_id}")
logger.info(f"成功删除终端用户信息记录: end_user_info_id={end_user_info_id}")
return {
"success": True,
"data": {"user_alias_id": user_alias_id},
"data": {"end_user_info_id": end_user_info_id},
"error": None
}
except ValueError:
logger.error(f"无效的 user_alias_id 格式: {user_alias_id}")
logger.error(f"无效的 end_user_info_id 格式: {end_user_info_id}")
return {
"success": False,
"data": None,
"error": "无效的用户别名记录ID格式"
"error": "无效的终端用户信息记录ID格式"
}
except Exception as e:
db.rollback()
logger.error(f"删除用户别名记录失败: user_alias_id={user_alias_id}, error={str(e)}")
logger.error(f"删除终端用户信息记录失败: end_user_info_id={end_user_info_id}, error={str(e)}")
return {
"success": False,
"data": None,