async def get_project_id(id: int = Query(...)) -> BaseRes: _, error = verify_project_deleted(id) if error: return error try: project: AtpProject = Db.select_by_primary_key(AtpProject, id) member_relation_list: List[AtpProjectMember] = Db.select_by_condition( AtpProjectMember, [ AtpProjectMember.project_id == id, AtpProjectMember.is_delete == 2 ] ) if project.img: file: AtpFileSystemFile = Db.select_by_primary_key(AtpFileSystemFile, project.img) project.img = { 'id': file.id, 'url': get_settings().archive_host + file.name } else: project.img = { 'id': 0, 'url': 'https://zos.alipayobjects.com/rmsportal/jkjgkEfvpUPVyRjUImniVslZfWPnJuuZ.png' } project.member = [] for member_relation in member_relation_list: user: SysUser = Db.select_by_primary_key(SysUser, member_relation.member_id) project.member.append({ 'id': user.id, 'cname': user.cname, }) return BaseRes(data=project) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def update_project_env( env_info: UpdateProjectEnv, token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_filed(env_info.project_id) if error: return error _, error = verify_project_member(token_user.user_id, env_info.project_id) if error: return error try: Db.update_by_condition( AtpProjectEnv, [AtpProjectEnv.is_delete == 2, AtpProjectEnv.id == env_info.id], { AtpProjectEnv.host: env_info.env_host, AtpProjectEnv.name: env_info.env_name, AtpProjectEnv.updator: token_user.user_id, AtpProjectEnv.update_time: datetime.datetime.now() } ) return BaseRes() except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def update_task(project_id: int = Body(..., embed=True), list_id: int = Body(..., embed=True), title: str = Body(..., embed=True), token_user: TokenUser = Depends(auth_token)) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error try: exists_condition = [ AtpOverviewList.is_delete == 2, AtpOverviewList.project_id == project_id, AtpOverviewList.title == title, AtpOverviewList.id != list_id ] count = Db.select_count_by_condition(AtpOverviewList.id, exists_condition) if count != 0: return BaseRes(status=0, error='任务栏标题已存在') condition = [ AtpOverviewList.id == list_id, AtpOverviewList.is_delete == 2, ] Db.update_by_condition( AtpOverviewList, condition, { AtpOverviewList.title: title, AtpOverviewList.updator: token_user.user_id, AtpOverviewList.update_time: datetime.datetime.now() }) return BaseRes() except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def execute_suite( request: ExecuteSuite, background_tasks: BackgroundTasks, token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_deleted(request.project_id) if error: return error _, error = verify_project_member(token_user.user_id, request.project_id) if error: return error if request.is_use_env and request.env_host: env_db_res: AtpProjectEnv = Db.select_by_primary_key(AtpProjectEnv, request.env_host) global_host = env_db_res.host else: if request.request_host: global_host = request.request_host else: global_host = '' case_relation: List[AtpProjectApiSuiteCaseRelation] = Db.select_by_condition( AtpProjectApiSuiteCaseRelation, [ AtpProjectApiSuiteCaseRelation.project_id == request.project_id, AtpProjectApiSuiteCaseRelation.suite_id == request.suite_id, AtpProjectApiSuiteCaseRelation.is_delete == 2, ], AtpProjectApiSuiteCaseRelation.sort ) request_list = [] for item in case_relation: case: AtpProjectApiCase = Db.select_by_primary_key(AtpProjectApiCase, item.case_id) case_item = { 'case_id': case.id, 'suite_id': request.suite_id, 'path': case.request_path, 'params': json.loads(case.request_query), 'body': json.loads(case.request_body), 'method': 'Get' if case.method == 1 else 'Post' } if global_host: case_item.setdefault('host', global_host) else: if case.is_use_env: request_host_item: AtpProjectEnv = Db.select_by_primary_key( AtpProjectEnv, case.env_host) case_item.setdefault('host', request_host_item.host) else: case_item.setdefault('host', case.request_host) request_headers = json.loads(deepcopy(case.request_headers)) if request_headers is None: request_headers = {} if request.global_headers: request_headers.update(request.global_headers) case_item.setdefault('headers', request_headers) else: case_item.setdefault('headers', request_headers) request_list.append(case_item)
async def get_workstation_projects(token_user: TokenUser = Depends( auth_token)) -> BaseRes: try: project_list: List[AtpProject] = Db.select_by_condition( AtpProject, [AtpProject.type == 1, AtpProject.is_delete == 2], AtpProject.create_time.desc()) parted_project_list = [] for project in project_list: is_part_in = Db.select_by_condition( AtpProjectMember, [ AtpProjectMember.is_delete == 2, AtpProjectMember.project_id == project.id, AtpProjectMember.member_id.in_([token_user.user_id]) ], ) if is_part_in: parted_project_list.append(project) if project.img: file: AtpFileSystemFile = Db.select_by_primary_key( AtpFileSystemFile, project.img) project.img = { 'id': file.id, 'url': get_settings().archive_host + file.name } else: project.img = { 'id': 0, 'url': 'https://zos.alipayobjects.com/rmsportal/jkjgkEfvpUPVyRjUImniVslZfWPnJuuZ.png' } session = Db.get_session() report_list: List[AtpProjectTestReport] = session.query( AtpProjectTestReport).join( AtpProject, AtpProject.id == AtpProjectTestReport.project_id).filter( AtpProjectTestReport.is_delete == 2, AtpProjectTestReport.creator == token_user.user_id, AtpProject.is_delete == 2).limit(10).all() total_projects_num = Db.select_count_by_condition( AtpProject.id, [AtpProject.is_delete == 2]) return BaseRes( data={ 'underway_projects': project_list[:6], 'parted_projects': parted_project_list[:6], 'my_reports': report_list, 'total_projects_num': total_projects_num, 'total_underway_projects_num': len(project_list) }) except Exception as e: logger.error(e) return BaseRes(status=0, error=str(e))
async def get_task_by_condition(project_id: int = Query(...), keyword: str = Query(None), relation_type: int = Query(...), filter_type: int = Query(...), token_user: TokenUser = Depends( auth_token)) -> BaseRes: _, error = verify_project_deleted(project_id) if error: return error try: task_list_condition: list = [ AtpOverviewList.is_delete == 2, AtpOverviewList.project_id == project_id ] task_list: List[AtpOverviewList] = Db.select_by_condition( AtpOverviewList, task_list_condition, AtpOverviewList.sort) for l in task_list: task_condition: list = [ AtpOverviewTask.is_delete == 2, AtpOverviewTask.project_id == project_id, AtpOverviewTask.list_id == l.id ] if keyword: task_condition.append( AtpOverviewTask.title.like(f'%{keyword}%')) if filter_type in [1, 2]: task_condition.append(AtpOverviewTask.status == filter_type) if relation_type == 2: task_condition.append( AtpOverviewTask.creator == token_user.user_id) tasks: List[AtpOverviewTask] = Db.select_by_condition( AtpOverviewTask, task_condition, AtpOverviewTask.sort) # 根据条件找出所有符合条件的, 再筛选我关注的 if relation_type == 3: target_tasks = [] for t in tasks: if token_user.user_id in json.loads(t.follower): target_tasks.append(t) tasks = target_tasks l.taskList = tasks for t in tasks: user: SysUser = Db.select_by_primary_key( SysUser, int(str(t.creator))) t.creator = { 'id': user.id if user else 0, 'cname': user.cname if user else '' } l.taskList = tasks return BaseRes(data=task_list) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def get_case_by_module_id(project_id: int = Body(..., embed=True), module_id: int = Body(None, embed=True), keyword: str = Body(None, embed=True)) -> BaseRes: _, error = verify_project_deleted(project_id) if error: return error condition = [ AtpProjectCase.is_delete == 2, AtpProjectCase.project_id == project_id ] if module_id: condition.append(AtpProjectCase.module_id == module_id) if keyword: condition.append(AtpProjectCase.name.like(f'%{keyword}%')) try: case_list: List[AtpProjectCase] = Db.select_by_condition( AtpProjectCase, condition, AtpProjectCase.id.desc()) index = 1 for case in case_list: case.index = index index += 1 case.steps = Db.select_by_condition(AtpProjectCaseStep, [ AtpProjectCaseStep.is_delete == 2, AtpProjectCaseStep.case_id == case.id ]) case.cname = Db.select_by_primary_key(SysUser, case.creator).cname case.module_name = Db.select_by_primary_key( AtpProjectModule, case.module_id).name return BaseRes(data=case_list)
async def get_all_user_roll(token_user: TokenUser = Depends(auth_token)) -> BaseRes: session = Db.get_session() try: user_list: List[SysUser] = session.query(SysUser).filter(*[ SysUser.is_delete == 2 ]).all() return_data = [] for user in user_list: user_roll_map: List[SysUserRole] = session.query(SysUserRole).filter(*[ SysUserRole.is_delete == 2, SysUserRole.user_id == user.id ]).all() roll_ids = [x.role_id for x in user_roll_map] return_data.append({ 'user_id': user.id, 'user_name': user.name, 'user_cname': user.cname, 'user_phone': user.phone, 'user_email': user.email, 'role_ids': roll_ids }) return BaseRes(data=return_data) except Exception as e: logger.warning(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def get_current_user(token_user: TokenUser = Depends(auth_token)) -> BaseRes: session = Db.get_session() try: user_role_list: List[SysUserRole] = session.query(SysUserRole).filter(*[ SysUserRole.is_delete == 2, SysUserRole.user_id == token_user.user_id ]).all() if len(user_role_list) == 0: return BaseRes(data=[]) user_role_id_list = [x.role_id for x in user_role_list] menu_map_list: List[tuple] = session.query(distinct(SysRoleMenu.menu_id)).filter(*[ SysRoleMenu.is_delete == 2, SysRoleMenu.role_id.in_(user_role_id_list) ]).all() menus_ids = set() for menu_map in menu_map_list: menus_ids.add(menu_map[0]) menus: List[SysMenu] = session.query(SysMenu).filter(*[ SysMenu.is_delete == 2, SysMenu.id.in_(menus_ids) ]).all() return_value = [] for m in menus: return_value.append({ 'id': m.id, 'name': m.name, 'regExp': m.menu_reg, 'path': m.menu_path, 'parentId': m.parent_id, 'icon': m.icon }) return BaseRes(data=return_value) except Exception as e: logger.warning(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def delete_user(user_id: int = Body(..., embed=True), token_user: TokenUser = Depends(auth_token)) -> BaseRes: session = Db.get_session() try: session.query(SysUser).filter(*[ SysUser.id == user_id, SysUser.is_delete == 2 ]).update({ SysUser.is_delete: 1, SysUser.updator: token_user.user_id, SysUser.update_time: datetime.now() }) session.query(AtpProjectMember).filter(*[ AtpProjectMember.is_delete == 2, AtpProjectMember.member_id == user_id ]).update({ AtpProjectMember.is_delete: 1, AtpProjectMember.updator: token_user.user_id, AtpProjectMember.update_time: datetime.now() }) session.commit() return BaseRes(data='success') except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=e)
async def create_project_case( request: ProjectCase, token_user: TokenUser = Depends(auth_token)) -> BaseRes: _, error = verify_project_filed(request.project_id) if error: return error _, error = verify_project_member(token_user.user_id, request.project_id) if error: return error session = Db.get_session() try: case = AtpProjectCase(name=request.name, module_id=request.module_id, project_id=request.project_id, priority=request.priority, precondition=request.precondition, remark=request.remark, creator=token_user.user_id, create_time=datetime.datetime.now()) session.add(case) session.commit() for step in request.steps: session.add( AtpProjectCaseStep(case_id=case.id, step=step.step, exception=step.exception, creator=token_user.user_id, create_time=datetime.datetime.now())) session.commit() return BaseRes()
async def update_project_type( id: int = Body(..., embed=True), project_type: int = Body(..., embed=True), token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_deleted(id) if error: return error _, error = verify_project_owner(token_user.user_id, id) if error: return error try: count = Db.update_by_condition( AtpProject, [AtpProject.id == id, AtpProject.is_delete == 2], { AtpProject.type: project_type, AtpProject.updator: token_user.user_id, AtpProject.update_time: datetime.datetime.now() } ) return BaseRes(data=count) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def del_project_img( file_id: int = Body(..., embed=True), task_id: int = Body(None, embed=True), token_user: TokenUser = Depends(auth_token) ) -> BaseRes: session = Db.get_session() file: AtpFileSystemFile = session.query(AtpFileSystemFile).get(file_id) if not file: return BaseRes(status=0, error='file not found') file_path = get_settings().static_path + file.name if not os.path.exists(file_path): return BaseRes(status=0, error='file not found') os.remove(file_path) if task_id: task: AtpOverviewTask = session.query(AtpOverviewTask).get(task_id) _, error = verify_project_filed(task.project_id) if error: return error _, error = verify_project_member(token_user.user_id, task.project_id) if error: return error img_list = json.loads(task.img) img_list.remove(file_id) task.img = json.dumps(img_list) session.commit() return BaseRes()
async def update_list_sort(project_id: int = Body(..., embed=True), start_index: int = Body(..., embed=True), end_index: int = Body(..., embed=True), token_user: TokenUser = Depends( auth_token)) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error session = Db.get_session() try: target_list_columns: List[AtpOverviewList] = session.query( AtpOverviewList).filter(*[ AtpOverviewList.is_delete == 2, AtpOverviewList.project_id == project_id, ]).order_by(AtpOverviewList.sort).all() new_sort = target_list_columns[end_index].sort if start_index < end_index: for i in target_list_columns[start_index + 1:end_index + 1]: i.sort -= 1 else: for i in target_list_columns[end_index:start_index]: i.sort += 1 target_list_columns[start_index].sort = new_sort session.commit() return BaseRes() except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e)) finally: session.close()
async def update_editor(project_id: int = Body(..., embed=True), title: str = Body(..., embed=True), type: int = Body(..., embed=True), token_user: TokenUser = Depends( auth_token)) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error session = Db.get_session() try: editor = AtpProjectEditor(project_id=project_id, title=title, type=type, creator=token_user.user_id, create_time=datetime.datetime.now(), updator=token_user.user_id, update_time=datetime.datetime.now()) session.add(editor) session.commit() return BaseRes(data={'id': editor.id}) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e)) finally: session.close()
async def add_user(user: AddUser, token_user: TokenUser = Depends(auth_token)) -> BaseRes: hash_paaword = get_password_hash(user.password) session = Db.get_session() try: new_user = SysUser( name=user.user_name, password=hash_paaword, cname=user.user_cname, email=user.email, phone=user.phone, creator=token_user.user_id, create_time=datetime.now() ) session.add(new_user) session.commit() for role_id in user.role_ids: session.add(SysUserRole( user_id=new_user.id, role_id=role_id, creator=token_user.user_id, create_time=datetime.now() )) session.commit() return BaseRes(data=new_user.id) except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=e)
async def delete_task(project_id: int = Body(..., embed=True), id: int = Body(..., embed=True), token_user: TokenUser = Depends(auth_token)) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error session = Db.get_session() try: delete_item: AtpOverviewTask = session.query(AtpOverviewTask).get(id) if delete_item: delete_item.is_delete = 1 delete_item.updator = token_user.user_id, delete_item.update_time = datetime.datetime.now() session.query(AtpOverviewTask).filter(*[ AtpOverviewTask.project_id == delete_item.project_id, AtpOverviewTask.list_id == delete_item.list_id, AtpOverviewTask .sort > delete_item.sort, AtpOverviewTask.is_delete == 2 ]).update({ AtpOverviewTask.sort: AtpOverviewTask.sort - 1, AtpOverviewTask.updator: token_user.user_id, AtpOverviewTask.update_time: datetime.datetime.now() }) session.commit() return BaseRes() except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e)) finally: session.close()
async def create_project( create_project: Project, token_user: TokenUser = Depends(auth_token) ) -> BaseRes: user_id = token_user.user_id session = Db.get_session() try: project: AtpProject = AtpProject( name=create_project.project_name, remark=create_project.project_desc, type=1, img=create_project.project_img, creator=user_id, create_time=datetime.datetime.now() ) session.add(project) session.commit() project_id = project.id for member_id in create_project.project_member: member: AtpProjectMember = AtpProjectMember( project_id=project_id, member_id=member_id, creator=user_id, create_time=datetime.datetime.now() ) session.add(member) session.commit() return BaseRes() except Exception as e: logger.error(traceback.format_exc()) session.rollback() return BaseRes(status=0, error=str(e))
async def delete_project_env( id: int = Body(..., embed=True), project_id: int = Body(..., embed=True), token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error session = Db.get_session() try: session.query(AtpProjectEnv).filter(AtpProjectEnv.is_delete == 2, AtpProjectEnv.id == id).update( { AtpProjectEnv.is_delete: 1, AtpProjectEnv.updator: token_user.user_id, AtpProjectEnv.update_time: datetime.datetime.now() } ) session.query(AtpProjectApiCase).filter( AtpProjectApiCase.is_delete == 2, AtpProjectApiCase.project_id == project_id, AtpProjectApiCase.env_host == id ).update({ AtpProjectApiCase.env_host: None }) session.commit() return BaseRes() except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def delete_suite( suite_id: int = Body(..., embed=True), project_id: int = Body(..., embed=True), suite_name: str = Body(None, embed=True), is_delete: int = Body(None, embed=True), token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error update_list = { AtpProjectApiSuite.updator: token_user.user_id, AtpProjectApiSuite.update_time: datetime.datetime.now() } if suite_name: update_list.setdefault(AtpProjectApiSuite.name, suite_name) if is_delete: update_list.setdefault(AtpProjectApiSuite.is_delete, int(is_delete)) try: count = Db.update_by_condition(AtpProjectApiSuite, [AtpProjectApiSuite.id == suite_id], update_list) return BaseRes(data=count) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def create_role( name: str = Body(..., embed=True), menu_list: List[int] = Body(..., embed=True), token_user: TokenUser = Depends(auth_token) ) -> BaseRes: session = Db.get_session() try: new_role = SysRole( role_name=name, creator=token_user.user_id, create_time=datetime.now() ) session.add(new_role) session.commit() for menu_id in menu_list: session.add(SysRoleMenu( menu_id=menu_id, role_id=new_role.id, creator=token_user.user_id, create_time=datetime.now() )) session.commit() return BaseRes(data=new_role.id) except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=e)
async def update_editor(id: int = Body(..., embed=True), project_id: int = Body(..., embed=True), title: str = Body(None, embed=True), data: str = Body(None, embed=True), is_delete: int = Body(None, embed=True), token_user: TokenUser = Depends( auth_token)) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error session = Db.get_session() try: editor: AtpProjectEditor = session.query(AtpProjectEditor).get(id) editor.updator = token_user.user_id editor.update_time = datetime.datetime.now() if is_delete: editor.is_delete = is_delete if title: editor.title = title if data: editor.data = data session.commit() return BaseRes(data={'id': id}) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e)) finally: session.close()
async def delete_api_case_by_id( id: int = Body(..., embed=True), project_id: int = Body(..., embed=True), token_user: TokenUser = Depends(auth_token) ): _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error try: update_count: int = Db.update_by_condition( AtpProjectApiCase, [ AtpProjectApiCase.id == id, AtpProjectApiCase.is_delete == 2, ], { AtpProjectApiCase.is_delete: 1, AtpProjectApiCase.updator: token_user.user_id, AtpProjectApiCase.update_time: datetime.datetime.now() } ) return BaseRes(data=update_count) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def update_task(project_id: int = Body(..., embed=True), task_id: int = Body(..., embed=True), value: Any = Body(..., embed=True), key: str = Body(..., embed=True), token_user: TokenUser = Depends(auth_token)) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_id) if error: return error session = Db.get_session() try: session.query(AtpOverviewTask).filter( *[AtpOverviewTask.id == task_id, AtpOverviewTask.is_delete == 2 ]).update({ getattr(AtpOverviewTask, key): value, AtpOverviewTask.updator: token_user.user_id, AtpOverviewTask.update_time: datetime.datetime.now() }) session.commit() return BaseRes() except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e)) finally: session.close()
async def get_project_progress(project_id: int = Query(...)) -> BaseRes: _, error = verify_project_deleted(project_id) if error: return error try: finish_count = Db.select_count_by_condition(AtpOverviewTask.id, [ AtpOverviewTask.is_delete == 2, AtpOverviewTask.project_id == project_id, AtpOverviewTask.status == 1 ]) total_count = Db.select_count_by_condition(AtpOverviewTask.id, [ AtpOverviewTask.is_delete == 2, AtpOverviewTask.project_id == project_id, ]) return BaseRes(data={'total': total_count, 'finish': finish_count}) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def update_module( request: UpdateModule, token_user: TokenUser = Depends(auth_token)) -> BaseRes: _, error = verify_project_filed(request.project_id) if error: return error _, error = verify_project_member(token_user.user_id, request.project_id) if error: return error try: Db.update_by_condition(AtpProjectModule, [ AtpProjectModule.is_delete == 2, AtpProjectModule.id == request.id ], {AtpProjectModule.name: request.name}) return BaseRes() except Exception as e: logger.error(e) return BaseRes(status=0, error=str(e))
async def get_all_report(project_id: int = Query(...)) -> BaseRes: _, error = verify_project_deleted(project_id) if error: return error try: report_list: List[AtpProjectTestReport] = Db.select_by_condition( AtpProjectTestReport, [ AtpProjectTestReport.is_delete == '2', AtpProjectTestReport.project_id == project_id ], AtpProjectTestReport.create_time.desc()) for report in report_list: report.cname = Db.select_by_primary_key(SysUser, report.creator).cname return BaseRes(data=report_list) except Exception as e: logger.error(e) return BaseRes(status=0, error=str(e))
async def get_all_menu(token_user: TokenUser = Depends(auth_token)) -> BaseRes: session = Db.get_session() try: menu_list: List[SysMenu] = session.query(SysMenu).filter(*[ SysRole.is_delete == 2 ]).all() return BaseRes(data=menu_list) except Exception as e: logger.warning(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def update_password(data: UpdatePassword, token_user: TokenUser = Depends(auth_token)) -> BaseRes: user: SysUser = Db.select_by_primary_key(SysUser, token_user.user_id) if verify_password(data.old_password, user.password): try: hash_paaword = get_password_hash(data.new_password) Db.update_by_condition( SysUser, [SysUser.id == token_user.user_id], { SysUser.password: hash_paaword, SysUser.updator: token_user.user_id, SysUser.update_time: datetime.now() }) return BaseRes() except Exception as e: logger.error(e) return BaseRes(status=0, error='更新密码失败') else: return BaseRes(status=0, error='密码错误')
async def get_current_user(token_user: TokenUser = Depends(auth_token)) -> BaseRes: current_user: SysUser = Db.select_by_primary_key(SysUser, token_user.user_id) data = { 'id': current_user.id, 'name': current_user.name, 'cname': current_user.cname, 'email': current_user.email, 'phone': current_user.phone } return BaseRes(data=data)