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 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_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)
def verify_project_owner(user_id: int, project_id: int):
res, error = verify_project_member(user_id, project_id)
if error:
return None, error
else:
project: AtpProject = Db.select_by_primary_key(AtpProject, project_id)
if project.creator == user_id:
return True, None
else:
return None, BaseRes(status=0, error='非项目负责人无权操作')
def verify_project_deleted(id: int):
project_id = id
project: AtpProject = Db.select_by_primary_key(AtpProject, project_id)
if not project:
return None, BaseRes(status=0, error='项目不存在')
else:
if project.is_delete == 1:
return None, BaseRes(status=0, error='项目不存在')
else:
return project, None
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_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 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='密码错误')
def verify_project_member(user_id: int, project_id: int):
user: SysUser = Db.select_by_primary_key(SysUser, user_id)
if not user:
return None, BaseRes(status=0, error='用户不存在')
else:
member_list: typing.List[AtpProjectMember] = Db.select_by_condition(
AtpProjectMember, [
AtpProjectMember.project_id == project_id,
AtpProjectMember.is_delete == 2
])
is_memeber = False
for member_item in member_list:
if member_item.member_id == user.id:
is_memeber = True
break
if is_memeber:
return True, None
else:
return None, BaseRes(status=0, error='非项目成员无权操作')
async def get_all_project(type: int = Query(...)) -> BaseRes:
try:
project_list: List[AtpProject] = Db.select_by_condition(
AtpProject,
[AtpProject.is_delete == 2, AtpProject.type == type],
AtpProject.create_time.desc()
)
for project in project_list:
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'
}
return BaseRes(data=project_list)
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 single_case_debug(apiCase: ApiCase) -> BaseRes:
request_host: str
if apiCase.request_host.is_user_env:
request_host_item: AtpProjectEnv = Db.select_by_primary_key(
AtpProjectEnv, int(apiCase.request_host.env_host))
request_host = request_host_item.host
else:
request_host = apiCase.request_host.request_host
request_path: str = apiCase.request_path
is_json_data: bool = False
if apiCase.request_headers:
for k, v in apiCase.request_headers.items():
if k.lower() == 'content-type' and v.lower() == 'application/json':
is_json_data = True
request_method: int = apiCase.request_method
try:
if request_method == reqest_consts.GET_METHOD:
res = requests.get(url=request_host + request_path,
headers=apiCase.request_headers,
params=apiCase.request_query,
timeout=reqest_consts.TIMEOUT)
elif request_method == reqest_consts.POST_METHOD:
if is_json_data:
res = requests.post(url=request_host + request_path,
headers=apiCase.request_headers,
params=apiCase.request_query,
json=apiCase.request_body,
timeout=reqest_consts.TIMEOUT)
else:
res = requests.post(url=request_host + request_path,
headers=apiCase.request_headers,
params=apiCase.request_query,
data=apiCase.request_body,
timeout=reqest_consts.TIMEOUT)
else:
return BaseRes(status=0, error='request method error')
duration_time = res.elapsed.seconds * 1000 + int(
res.elapsed.microseconds / (1000))
return_data = {
'response': res.text,
'status': res.status_code,
'time': duration_time,
'assert': 0 if str(res.status_code).startswith('4') else 1
}
return BaseRes(data=return_data)
except ConnectTimeout as e:
logger.error(e)
return_data = {
# 'response': f'Timeout! url : {request_host + request_path}!',
'response': str(e),
'status': 0,
'time': 0,
'assert': 0
}
return BaseRes(data=return_data)
except Exception as e:
logger.error(e)
return_data = {
# 'response': f'There was an error connecting to {request_host + request_path} !',
'response': str(e),
'status': 0,
'time': 0,
'assert': 0
}
return BaseRes(data=return_data)
async def get_api_case_by_condition(
project_id: int = Query(...),
suite_id: int = Query(...),
page_num: int = Query(...),
page_size: int = Query(...),
type: int = Query(...),
keyword: Optional[str] = Query(None)
) -> BaseRes:
_, error = verify_project_deleted(project_id)
if error:
return error
try:
if page_num == 0 and page_size == 0:
offset = None
limit = None
else:
offset = page_size * (page_num - 1)
limit = page_size
condition_list: list = [
AtpProjectApiCase.is_delete == 2,
AtpProjectApiCase.project_id == project_id,
AtpProjectApiCase.suite_id == suite_id
]
if keyword and keyword != '':
condition_list.append(AtpProjectApiCase.name.like(f'%{keyword}%'))
if type in [1, 2]:
condition_list.append(AtpProjectApiCase.method == type)
api_case_list: List[AtpProjectApiCase] = Db.select_by_condition(
AtpProjectApiCase,
condition_list,
AtpProjectApiCase.id,
offset,
limit
)
total: int = Db.select_count_by_condition(AtpProjectApiCase.id, condition_list)
res_list: list = []
order_id = page_size * (page_num - 1)
for item in api_case_list:
item_dict: dict = {}
order_id += 1
item_dict.setdefault('id', item.id)
item_dict.setdefault('order_id', order_id)
item_dict.setdefault('name', item.name)
item_dict.setdefault('method', item.method)
item_dict.setdefault('is_use_env', item.is_use_env)
item_dict.setdefault('env_host', item.env_host)
item_dict.setdefault('request_url', item.request_url)
item_dict.setdefault('request_headers', json.loads(item.request_headers))
item_dict.setdefault('request_query', json.loads(item.request_query))
item_dict.setdefault('request_body', item.request_body)
item_dict.setdefault('suite_id', item.suite_id)
if item.is_use_env:
if item.env_host:
env: AtpProjectEnv = Db.select_by_primary_key(AtpProjectEnv, item.env_host)
item_dict.setdefault('real_host', env.host)
else:
item_dict.setdefault('real_host', None)
else:
item_dict.setdefault('real_host', None)
res_list.append(item_dict)
return BaseRes(data={'data': res_list, 'total': total})
except Exception as e:
logger.error(traceback.format_exc())
return BaseRes(status=0, error=str(e))
async def get_report_detail(
report_id: int = Query(...),
project_id: int = Query(...),
) -> BaseRes:
_, error = verify_project_deleted(project_id)
if error:
return error
try:
report_detail_list: List[
AtpProjectTestReportDetail] = Db.select_by_condition(
AtpProjectTestReportDetail, [
AtpProjectTestReportDetail.is_delete == '2',
AtpProjectTestReportDetail.report_id == report_id
], AtpProjectTestReportDetail.id)
report: AtpProjectTestReport = Db.select_by_primary_key(
AtpProjectTestReport, report_id)
suite: AtpProjectApiSuite = Db.select_by_primary_key(
AtpProjectApiSuite, report.suite_id)
project: AtpProject = Db.select_by_primary_key(AtpProject,
report.project_id)
user: SysUser = Db.select_by_primary_key(SysUser, report.creator)
status_code_distribution = {}
for report_detail in report_detail_list:
case: AtpProjectApiCase = Db.select_by_primary_key(
AtpProjectApiCase, report_detail.case_id)
report_detail.case_name = case.name
if report.global_host:
report_detail.host = report.global_host
else:
if case.is_use_env:
report_detail.host = Db.select_by_primary_key(
AtpProjectEnv, case.env_host).host
else:
report_detail.host = case.request_host
report_detail.path = case.request_path
if report.global_headers:
init_header = json.loads(deepcopy(case.request_headers))
if init_header is None:
report_detail.headers = json.loads(report.global_headers)
else:
init_header.update(json.loads(report.global_headers))
report_detail.headers = init_header
else:
report_detail.headers = json.loads(case.request_headers)
report_detail.params = json.loads(case.request_query)
report_detail.body = json.loads(case.request_body)
if status_code_distribution.get(report_detail.status, None):
status_code_distribution[
report_detail.status] = status_code_distribution[
report_detail.status] + 1
else:
status_code_distribution.setdefault(report_detail.status, 1)
res = {
'report_id': report_id,
'report_name': report.report_name,
'suite_id': report.suite_id,
'suite_name': suite.name,
'project_id': report.project_id,
'project_name': project.name,
'global_host': report.global_host,
'global_headers': report.global_headers,
'is_save_cookie': report.is_save_cookie,
'total_case_num': report.total_case_num,
'success_case_num': report.success_case_num,
'failed_case_num': report.failed_case_num,
'status_code_distribution': status_code_distribution,
'cname': user.cname,
'detail': report_detail_list
}
return BaseRes(data=res)