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()
