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 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 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 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 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 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 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 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 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_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 update_suite_case_sort( before_id: int = Body(..., embed=True), after_id: int = Body(..., embed=True), project_id: int = Body(..., embed=True), suite_id: int = 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: all_relation: List[AtpProjectApiSuiteCaseRelation] = session.query(AtpProjectApiSuiteCaseRelation).filter( AtpProjectApiSuiteCaseRelation.is_delete == 2, AtpProjectApiSuiteCaseRelation.suite_id == suite_id ).order_by(AtpProjectApiSuiteCaseRelation.sort).all() before_index = None after_index = None for index, relation in enumerate(all_relation): if relation.case_id == before_id: before_index = index if relation.case_id == after_id: after_index = index if type == 1: temp = all_relation[before_index] del all_relation[before_index] temp.sort = all_relation[after_index].sort all_relation.insert(after_index, temp) for i, v in enumerate(all_relation[after_index + 1:]): v.sort = i + after_index + 2 elif type == 2: temp = all_relation[before_index] del all_relation[before_index] all_relation.insert(after_index, temp) for i, v in enumerate(all_relation[before_index:]): v.sort = i + before_index + 1 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_list(project_id: int = Body(..., embed=True), list_id: int = Body(..., embed=True), title: str = Body(..., embed=True), priority: int = Body(..., embed=True), follower: List[int] = Body(..., embed=True), description: str = Body(None, embed=True), attachment: List[int] = Body(..., embed=True), relevance_case: List[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: max_sort_item = session.query(func.max(AtpOverviewTask.sort)).filter(*[ AtpOverviewTask.is_delete == 2, AtpOverviewTask.project_id == project_id, AtpOverviewTask.list_id == list_id ]).first() if max_sort_item[0]: max_sort = max_sort_item[0] + 1 else: max_sort = 1 session.add( AtpOverviewTask(title=title, project_id=project_id, sort=max_sort, description=description, priority=priority, follower=json.dumps(follower), img=json.dumps(attachment), relevance_case=json.dumps(relevance_case), list_id=list_id, status=2, creator=token_user.user_id, create_time=datetime.datetime.now(), is_delete=2)) 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_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 update_project_api_case( update_project_api_case: UpdateProjectApiCase, token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_filed(update_project_api_case.project_id) if error: return error _, error = verify_project_member(token_user.user_id, update_project_api_case.project_id) if error: return error try: request_headers: str = json.dumps(update_project_api_case.request_headers) request_query: str = json.dumps(update_project_api_case.request_query) request_body: str = str(update_project_api_case.request_body) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e)) try: db_res: int = Db.update_by_condition( AtpProjectApiCase, [ AtpProjectApiCase.id == update_project_api_case.id, AtpProjectApiCase.is_delete == 2 ], { AtpProjectApiCase.name: update_project_api_case.name, AtpProjectApiCase.method: update_project_api_case.request_method, AtpProjectApiCase.project_id: update_project_api_case.project_id, AtpProjectApiCase.suite_id: update_project_api_case.suite_id, AtpProjectApiCase.request_url: update_project_api_case.request_url, AtpProjectApiCase.is_use_env: update_project_api_case.request_host.is_user_env, AtpProjectApiCase.env_host: update_project_api_case.request_host.env_host, AtpProjectApiCase.request_headers: request_headers, AtpProjectApiCase.request_query: request_query, AtpProjectApiCase.request_body: request_body, AtpProjectApiCase.updator: token_user.user_id, AtpProjectApiCase.update_time: datetime.datetime.now() } ) return BaseRes(data=db_res) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def create_list(project_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 session = Db.get_session() try: exists_condition = [ AtpOverviewList.is_delete == 2, AtpOverviewList.project_id == project_id, AtpOverviewList.title == title ] count = session.query(func.count( AtpOverviewList.id)).filter(*exists_condition).all()[0][0] if count != 0: return BaseRes(status=0, error='任务栏标题已存在') max_sort_item = session.query(func.max(AtpOverviewList.sort)).filter(*[ AtpOverviewList.is_delete == 2, AtpOverviewList.project_id == project_id ]).first() if max_sort_item[0]: max_sort = max_sort_item[0] + 1 else: max_sort = 1 session.add( AtpOverviewList(title=title, project_id=project_id, sort=max_sort, creator=token_user.user_id, create_time=datetime.datetime.now(), is_delete=2)) 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_suite( project_id: int = Body(..., embed=True), suite_name: 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 suite = AtpProjectApiSuite(name=suite_name, project_id=project_id, creator=token_user.user_id, create_time=datetime.datetime.now()) try: Db.insert(suite) return BaseRes() except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def upload_project_img( projectImg: UploadFile = File(...), project_id=Body(None, embed=True), token_user: TokenUser = Depends(auth_token) ) -> BaseRes: encrypt_filename: str = hashlib.md5((projectImg.filename + str(time.time())).encode()).hexdigest() suffix = projectImg.content_type.split('/')[1] filename = encrypt_filename + '.' + suffix try: with open(get_settings().static_path + filename, 'wb+') as f: f.write(await projectImg.read()) session = Db.get_session() file = AtpFileSystemFile( name=filename, creator=token_user.user_id, create_time=datetime.datetime.now() ) session.add(file) session.commit() if project_id: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_owner(token_user.user_id, project_id) if error: return error session.query(AtpProject) \ .filter(*[AtpProject.id == project_id, AtpProject.is_delete == 2]) \ .update({ # AtpProject.img: 'http://localhost:8900/static/' + filename, AtpProject.img: file.id, AtpProject.updator: token_user.user_id, AtpProject.update_time: datetime.datetime.now() }) session.commit() return BaseRes(data={'id': file.id, 'fileName': filename, 'url': get_settings().archive_host + filename}) except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def delete_module(id_list: List[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(AtpProjectModule).filter( AtpProjectModule.is_delete == 2, AtpProjectModule.id.in_(id_list)).update( {AtpProjectModule.is_delete: 1}, synchronize_session=False) session.commit() return BaseRes() except Exception as e: session.rollback() logger.error(e) return BaseRes(status=0, error=str(e))
async def upload_task_img(projectImg: UploadFile = File(...), project_id=Body(..., embed=True), task_id=Body(None, embed=True), token_user: TokenUser = Depends( auth_token)) -> BaseRes: _, error = verify_project_filed(project_id) if error: return error _, error = verify_project_owner(token_user.user_id, project_id) if error: return error encrypt_filename: str = hashlib.md5( (projectImg.filename + str(time.time())).encode()).hexdigest() suffix = projectImg.content_type.split('/')[1] filename = encrypt_filename + '.' + suffix try: with open(get_settings().static_path + filename, 'wb+') as f: f.write(await projectImg.read()) session = Db.get_session() file = AtpFileSystemFile(name=filename, creator=token_user.user_id, create_time=datetime.datetime.now()) session.add(file) session.commit() if task_id: task: AtpOverviewTask = session.query(AtpOverviewTask).get(task_id) file_ids = json.loads(task.img) if task.img else [] file_ids.append(file.id) task.img = json.dumps(file_ids) session.commit() return BaseRes( data={ 'fileName': filename, 'id': file.id, 'url': get_settings().archive_host + filename }) except Exception as e: logger.error(e) return BaseRes(status=0, error=str(e))
async def delete_report_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( AtpProjectTestReport, [ AtpProjectTestReport.id == id, AtpProjectTestReport.is_delete == '2', ], { AtpProjectTestReport.is_delete: '1', AtpProjectTestReport.updator: token_user.user_id, AtpProjectTestReport.update_time: datetime.datetime.now() }) return BaseRes(data=update_count) except Exception as e: logger.error(e) return BaseRes(status=0, error=str(e))
async def create_project_case(project_id: int = Body(..., embed=True), case_id_list: List[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() now_time = datetime.datetime.now() try: session.query(AtpProjectCase).filter( AtpProjectCase.is_delete == 2, AtpProjectCase.id.in_(case_id_list)).update( { AtpProjectCase.is_delete: 1, AtpProjectCase.updator: token_user.user_id, AtpProjectCase.update_time: now_time }, synchronize_session=False) session.query(AtpProjectCaseStep).filter( AtpProjectCaseStep.is_delete == 2, AtpProjectCaseStep.case_id.in_(case_id_list)).update( { AtpProjectCaseStep.is_delete: 1, AtpProjectCaseStep.updator: token_user.user_id, AtpProjectCaseStep.update_time: now_time }, synchronize_session=False) session.commit() return BaseRes() except Exception as e: session.rollback() logger.error(e) return BaseRes(status=0, error=str(e))
async def create_project_api_case( project_api_case: ProjectApiCase, token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_filed(project_api_case.project_id) if error: return error _, error = verify_project_member(token_user.user_id, project_api_case.project_id) if error: return error try: request_headers: str = json.dumps(project_api_case.request_headers) request_query: str = json.dumps(project_api_case.request_query) request_body: str = project_api_case.request_body except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error='json转换异常 : ' + str(e)) atp_project_api_case: AtpProjectApiCase = AtpProjectApiCase( name=project_api_case.name, method=project_api_case.request_method, project_id=project_api_case.project_id, suite_id=project_api_case.suite_id, request_url=project_api_case.request_url, is_use_env=project_api_case.request_host.is_user_env, env_host=project_api_case.request_host.env_host, request_headers=request_headers, request_query=request_query, request_body=request_body, creator=token_user.user_id, create_time=datetime.datetime.now() ) try: Db.insert(atp_project_api_case) return BaseRes() except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def create_project_env( env_info: ProjectEnv, 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.insert( AtpProjectEnv( name=env_info.env_name, host=env_info.env_host, project_id=env_info.project_id, creator=token_user.user_id, create_time=datetime.datetime.now() ) ) return BaseRes() except Exception as e: logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e))
async def create_module( request: Module, 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: if request.parent_id != 0: parent_module: AtpProjectModule = Db.select_by_primary_key( AtpProjectModule, request.parent_id) if not parent_module: return BaseRes(status=0, error='父模块不存在') Db.insert( AtpProjectModule(name=request.name, parent_id=request.parent_id, project_id=request.project_id, creator=token_user.user_id, create_time=datetime.datetime.now())) return BaseRes() except Exception as e: logger.error(e) return BaseRes(status=0, error=str(e))
async def update_project_case( request: UpdateProjectCase, 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() now_time = datetime.datetime.now() try: session.query(AtpProjectCase).filter( AtpProjectCase.is_delete == 2, AtpProjectCase.id == request.id).update({ AtpProjectCase.name: request.name, AtpProjectCase.priority: request.priority, AtpProjectCase.precondition: request.precondition, AtpProjectCase.remark: request.remark, AtpProjectCase.module_id: request.module_id, AtpProjectCase.updator: token_user.user_id, AtpProjectCase.update_time: now_time }) current_step_ids = [] for step in request.steps: if step.id: current_step_ids.append(step.id) session.query(AtpProjectCaseStep).filter( AtpProjectCaseStep.is_delete == 2, AtpProjectCaseStep.id == step.id).update({ AtpProjectCaseStep.step: step.step, AtpProjectCaseStep.exception: step.exception, AtpProjectCaseStep.updator: token_user.user_id, AtpProjectCaseStep.update_time: now_time }) else: session.add( AtpProjectCaseStep(case_id=request.id, step=step.step, exception=step.exception, creator=token_user.user_id, create_time=now_time)) session.query(AtpProjectCaseStep).filter( AtpProjectCaseStep.is_delete == 2, AtpProjectCaseStep.id.notin_(current_step_ids)).update( { AtpProjectCaseStep.is_delete: 1, AtpProjectCaseStep.updator: token_user.user_id, AtpProjectCaseStep.update_time: now_time }, synchronize_session=False) session.commit() return BaseRes() except Exception as e: session.rollback() logger.error(e) return BaseRes(status=0, error=str(e))
async def update_suite_case_relation( suite_id: int = Body(..., embed=True), project_id: int = Body(..., embed=True), case_id_list: List[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: all_relation: List[AtpProjectApiSuiteCaseRelation] = session.query(AtpProjectApiSuiteCaseRelation).filter( # AtpProjectApiSuiteCaseRelation.is_delete == 2, AtpProjectApiSuiteCaseRelation.suite_id == suite_id, ).order_by(AtpProjectApiSuiteCaseRelation.case_id).all() current_case_id_list = [] for relation in all_relation: if relation.is_delete == 2: current_case_id_list.append(relation.case_id) remove_case_id_list = list(set(current_case_id_list) - set(case_id_list)) new_add_case_id_list = list(set(case_id_list) - set(current_case_id_list)) new_add_case_id_list.sort() def filter_relation(arg: AtpProjectApiSuiteCaseRelation): start_sort = 90000 if arg.case_id in remove_case_id_list: arg.is_delete = 1 return False if arg.case_id in new_add_case_id_list: new_add_case_id_list.remove(arg.case_id) arg.is_delete = 2 arg.sort = start_sort start_sort += 1 return True return True filtered_all_relation: List[AtpProjectApiSuiteCaseRelation] = list(filter(filter_relation, all_relation)) for new_add_case_id in new_add_case_id_list: new_obj = AtpProjectApiSuiteCaseRelation( case_id=new_add_case_id, suite_id=suite_id, project_id=project_id, creator=token_user.user_id, create_time=datetime.datetime.now(), sort=99999 ) filtered_all_relation.append(new_obj) session.add(new_obj) filtered_all_relation.sort(key=lambda x: x.sort) for i, v in enumerate(filtered_all_relation): v.sort = i + 1 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_project_id( project: UpdateProject, token_user: TokenUser = Depends(auth_token) ) -> BaseRes: _, error = verify_project_filed(project.id) if error: return error _, error = verify_project_owner(token_user.user_id, project.id) if error: return error session = Db.get_session() try: session.query(AtpProject).filter(AtpProject.id == project.id, AtpProject.is_delete == 2).update( { AtpProject.name: project.project_name, AtpProject.remark: project.project_desc, AtpProject.updator: token_user.user_id, AtpProject.update_time: datetime.datetime.now() } ) new_member_id_list = project.project_member old_memeber_id_list = [] items: List[AtpProjectMember] = session.query(AtpProjectMember).filter( AtpProjectMember.is_delete == 2, AtpProjectMember.project_id == project.id ).all() for item in items: old_memeber_id_list.append(item.member_id) added_member = set(new_member_id_list) - set(old_memeber_id_list) lost_member = set(old_memeber_id_list) - set(new_member_id_list) for add_member_id in added_member: instance = session.query(AtpProjectMember).filter( AtpProjectMember.project_id == project.id, AtpProjectMember.member_id == add_member_id, AtpProjectMember.is_delete == 1 ) if instance.first(): instance.update({ AtpProjectMember.is_delete: 2, AtpProjectMember.updator: token_user.user_id, AtpProjectMember.update_time: datetime.datetime.now() }) else: session.add(AtpProjectMember( project_id=project.id, member_id=add_member_id, creator=token_user.user_id, create_time=datetime.datetime.now() )) if len(lost_member) != 0: session.query(AtpProjectMember).filter( AtpProjectMember.is_delete == 2, AtpProjectMember.project_id == project.id, AtpProjectMember.member_id.in_(list(lost_member))) \ .update({ AtpProjectMember.is_delete: 1, AtpProjectMember.updator: token_user.user_id, AtpProjectMember.update_time: datetime.datetime.now() }, synchronize_session=False) session.commit() return BaseRes(data=project) except Exception as e: session.rollback() logger.error(traceback.format_exc()) return BaseRes(status=0, error=str(e)) finally: session.close()
async def update_task_sort(project_id: int = Body(..., embed=True), start_list_id: int = Body(..., embed=True), end_list_id: int = Body(..., embed=True), id: int = Body(..., embed=True), before_id: int = Body(None, embed=True), after_id: 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: source_task: AtpOverviewTask = session.query(AtpOverviewTask).get(id) before_task: AtpOverviewTask or None = None after_task: AtpOverviewTask or None = None if before_id: before_task = session.query(AtpOverviewTask).get(before_id) if after_id: after_task = session.query(AtpOverviewTask).get(after_id) start_list: AtpOverviewList = session.query(AtpOverviewList).get( start_list_id) end_list: AtpOverviewList = session.query(AtpOverviewList).get( end_list_id) if not (start_list and end_list): return BaseRes() if start_list_id == end_list_id: target_task_columns: List[AtpOverviewTask] = session.query( AtpOverviewTask).filter(*[ AtpOverviewTask.is_delete == 2, AtpOverviewList.project_id == project_id, AtpOverviewTask.list_id == end_list_id ]).order_by(AtpOverviewTask.sort).all() if after_task: if source_task.sort < after_task.sort: new_sort = after_task.sort - 1 temp_list = [ x for x in target_task_columns if source_task.sort < x.sort < after_task.sort ] for i in temp_list: i.sort -= 1 else: new_sort = after_task.sort for i in [ x for x in target_task_columns if after_task.sort <= x.sort < source_task.sort ]: i.sort += 1 else: # start<end并且end为最后一个 new_sort = target_task_columns[-1].sort temp_list = [ x for x in target_task_columns if source_task.sort < x.sort < target_task_columns[-1].sort + 1 ] for i in temp_list: i.sort -= 1 source_task.sort = new_sort else: start_task_columns: List[AtpOverviewTask] = session.query( AtpOverviewTask).filter(*[ AtpOverviewTask.is_delete == 2, AtpOverviewList.project_id == project_id, AtpOverviewTask.list_id == start_list_id ]).order_by(AtpOverviewTask.sort).all() end_task_columns: List[AtpOverviewTask] = session.query( AtpOverviewTask).filter(*[ AtpOverviewTask.is_delete == 2, AtpOverviewList.project_id == project_id, AtpOverviewTask.list_id == end_list_id ]).order_by(AtpOverviewTask.sort).all() for i in [ x for x in start_task_columns if x.sort > source_task.sort ]: i.sort -= 1 if after_task and before_task: new_sort = after_task.sort for i in [ x for x in end_task_columns if x.sort >= after_task.sort ]: i.sort += 1 elif after_task and not before_task: new_sort = after_task.sort for i in [ x for x in end_task_columns if x.sort >= after_task.sort ]: i.sort += 1 elif before_task and not after_task: new_sort = before_task.sort + 1 for i in [ x for x in end_task_columns if x.sort > before_task.sort ]: i.sort += 1 else: new_sort = 1 init_sort = 2 for i in end_task_columns: i.sort = init_sort init_sort += 1 source_task.sort = new_sort source_task.list_id = end_list_id 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()