def update():
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
scheduling = Scheduling.query.get_or_404(fromData['scheduling_id'])
scheduling.scheduling_title = fromData['scheduling_title']
scheduling.scheduling_cron = fromData['scheduling_cron']
scheduling.email_address = fromData['email_address']
db.session.commit()
taskList = fromData['caseList']
TaskCase.query.filter(
TaskCase.scheduling_id == fromData["scheduling_id"]).delete(
synchronize_session=False)
db.session.commit()
for task in taskList:
taskCase = TaskCase(scheduling_id=fromData['scheduling_id'],
case_id=task['case_id'])
db.session.add(taskCase)
db.session.commit()
# 删除任务
remove_task(fromData['scheduling_id'])
# 添加任务
addtask(fromData, fromData['scheduling_id'])
return jsonify(common.trueReturn('', '修改成功'))
else:
return jsonify(result)
def updateAps():
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
scheduling = Scheduling.query.get_or_404(fromData['scheduling_id'])
schedulingJson = {}
schedulingJson['scheduling_id'] = scheduling.scheduling_id
schedulingJson['scheduling_title'] = scheduling.scheduling_title
schedulingJson['scheduling_on'] = scheduling.scheduling_on
schedulingJson['scheduling_cron'] = scheduling.scheduling_cron
schedulingJson['email_address'] = scheduling.email_address
taskCaseList = TaskCase.query.filter(
TaskCase.scheduling_id == fromData["scheduling_id"]).all()
task_jsonarray = []
for task in taskCaseList:
task_dict = {}
task_dict['task_id'] = task.task_id
task_dict['case_id'] = task.case_id
user_case = UserCase.query.get_or_404(task.case_id)
task_dict['scheduling_id'] = task.scheduling_id
task_dict['case_name'] = user_case.case_name
task_dict['request_address'] = user_case.request_address
task_jsonarray.append(task_dict)
schedulingJson['caseData'] = task_jsonarray
return jsonify(common.trueReturn(schedulingJson, '任务查询成功'))
else:
return jsonify(result)
def add():
"""
用例新增
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
if fromData is not None:
case_name = fromData['case_name']
case_desc = fromData['case_desc']
request_address = fromData['request_address']
if fromData['email_address'] != None:
email_address = fromData['email_address']
list_case = []
for case in fromData['envData']:
case_env = CaseEnv(project_id=case['pro_id'], modules_id=case['mod_id'], env_id=case['env_id'])
list_case.append(case_env)
list_scene = []
for scene in fromData['sceneData']:
case_scene = CaseScene(project_id=scene['pro_id'], sceneList_id=scene['scene_id'])
list_scene.append(case_scene)
user_case = UserCase(case_name=case_name, case_desc=case_desc, email_address=email_address,
request_address=str(request_address),
case_env=list_case, caseScene=list_scene)
db.session.add(user_case)
db.session.commit()
return jsonify(common.trueReturn('', '用例新增成功'))
else:
return jsonify(result)
def updateProject():
"""
项目修改
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
project_id = request.json.get('project_id')
project_name = request.json.get('project_name')
project_desc = request.json.get('project_desc')
status = request.json.get('status')
project = Project.query.get_or_404(project_id)
project.project_name = project_name
if status:
project.status = 1
else:
project.status = 2
project.project_desc = project_desc
project.update_time = datetime.now()
db.session.commit()
return jsonify(common.trueReturn('', '项目修改成功'))
else:
return jsonify(result)
def update():
"""
修改用例
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
if fromData is not None:
CaseEnv.query.filter(CaseEnv.uc_id == fromData["case_id"]).delete(synchronize_session=False)
db.session.commit()
CaseScene.query.filter(CaseScene.uc_id == fromData["case_id"]).delete(synchronize_session=False)
db.session.commit()
for case in fromData['envData']:
case_env = CaseEnv(project_id=case['pro_id'], modules_id=case['mod_id'], env_id=case['env_id'],
uc_id=fromData["case_id"])
db.session.add(case_env)
db.session.commit()
for scene in fromData['sceneData']:
case_scene = CaseScene(project_id=scene['pro_id'], sceneList_id=scene['scene_id'],uc_id=fromData["case_id"])
db.session.add(case_scene)
db.session.commit()
userCase = UserCase.query.get_or_404(fromData["case_id"])
userCase.case_name = fromData['case_name']
userCase.case_desc = fromData['case_desc']
userCase.request_address = fromData['request_address']
userCase.email_address = fromData['email_address']
db.session.commit()
return jsonify(common.trueReturn('', '修改成功'))
else:
return jsonify(result)
def identify(self, request):
"""
用户鉴权
:return: list
"""
auth_header = request.headers.get('Authorization')
if auth_header:
auth_tokenArr = auth_header.split(" ")
if not auth_tokenArr or auth_tokenArr[0] != 'JWT' or len(auth_tokenArr) != 2:
result = common.falseReturn('', '请传递正确的验证头信息')
else:
auth_token = auth_tokenArr[1]
payload = self.decode_auth_token(auth_token)
if not isinstance(payload, str):
user = Admin.get(Admin, payload['data']['id'])
if user is None:
result = common.falseReturn('', '找不到该用户信息')
else:
if user.login_time == payload['data']['login_time']:
result = common.trueReturn(user.id, '请求成功')
else:
result = common.falseReturn('', 'Token已更改，请重新登录获取')
else:
result = common.falseReturn('', payload)
else:
result = common.falseReturn('', '没有提供认证token')
return result
def updateModular():
"""
模块修改
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
mod_id = request.json.get('mod_id')
mod_name = request.json.get('mod_name')
mod_desc = request.json.get('mod_desc')
pro_id = request.json.get('pro_id')
status = request.json.get('status')
modules = Modules.query.get_or_404(mod_id)
modules.modules_name = mod_name
modules.modules_desc = mod_desc
modules.status = status
modules.project_id = pro_id
modules.update_time = datetime.now()
if status:
modules.status = '1'
else:
modules.status = '2'
db.session.commit()
return jsonify(common.trueReturn('', '模块修改成功'))
else:
return jsonify(result)
def addjob():
"""
添加任务
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
caseList = fromData['caseList']
cronStr = fromData['scheduling_cron']
scheduling_title = fromData['scheduling_title']
email_address = fromData['email_address']
cronStr = cronStr.replace("?", "*")
cronStrValue = cronStr
id = str(uuid.uuid1()).replace('-', '')
scheduling = Scheduling(scheduling_id=id,
scheduling_title=scheduling_title,
scheduling_cron=str(cronStrValue),
scheduling_on='0',
email_address=email_address)
db.session.add(scheduling)
db.session.commit()
for case in caseList:
taskCase = TaskCase(scheduling_id=id, case_id=case['case_id'])
db.session.add(taskCase)
db.session.commit()
addtask(fromData, id)
return jsonify(common.trueReturn('', '任务新增成功'))
else:
return jsonify(result)
def index(page=1):
"""
项目查询
:param page: 页数
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = json.loads(request.args['0'])
param = []
page = fromData['page']
project_name = fromData['proname']
scenename = fromData['scenename']
# 拼接查询条件
stmt = Project.query.with_entities(Project.project_id).filter(
Project.project_name.like("%" + project_name + "%")).subquery()
if scenename != 'None' and len(scenename) > 0:
param.append(SceneList.scene_name.like("%" + scenename + "%"))
# 每页显示数
per_page = current_app.config['INTERFACE_PER_PAGE']
# 分页对象
pagination = db.session.query(SceneList).join(
stmt,
SceneList.project_id == stmt.c.project_id).filter(*param).group_by(
SceneList.sceneList_id).paginate(page, per_page=per_page)
# 总条数
count = db.session.query(SceneList).join(
stmt,
SceneList.project_id == stmt.c.project_id).filter(*param).group_by(
SceneList.sceneList_id).count()
# # 总页数
page_count = math.ceil(count / per_page)
# 当前页数的记录列表
sceneList = pagination.items
scene_list = []
for item in sceneList:
scene_dic = {}
scene_dic['sceneList_id'] = item.sceneList_id
scene_dic['scene_name'] = item.scene_name
scene_dic['project_id'] = item.project_id
project = Project.query.with_entities(Project.project_name).filter(
Project.project_id == item.project_id).all()
scene_dic['project_name'] = project[0].project_name
scene_dic['scene_desc'] = item.scene_desc
scene_list.append(scene_dic)
list_dic = {}
list_dic['list'] = scene_list
list_dic['count'] = count
list_dic['page_count'] = page_count
list_dic['per_page'] = per_page
return jsonify(common.trueReturn(list_dic, '场景查询成功'))
else:
return jsonify(result)
def delete():
"""
删除项目
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
project_id = request.json.get('project_id')
Project.query.filter(Project.project_id == project_id).delete(
synchronize_session=False)
db.session.commit()
db.session.close()
Modules.query.filter(Modules.project_id == project_id).delete(
synchronize_session=False)
db.session.commit()
db.session.close()
environment = Environment.query.with_entities(
Environment.env_id).filter(
Environment.project_id == project_id).all()
for env in environment:
parameter = Parameter.query.filter(
Parameter.env_id == env.env_id).first()
if parameter is not None:
Parameter.query.filter(Parameter.env_id == env.env_id).delete(
synchronize_session=False)
db.session.commit()
db.session.close()
# 删除 调用接口
transfer = Transfer.query.filter(
Transfer.tra_need_env_id == env.env_id).first()
if transfer is not None:
transfer_all = Transfer.query.filter(
Transfer.tra_need_env_id == env.env_id).all()
for tar in transfer_all:
db.session.delete(tar)
db.session.commit()
db.session.close()
# 删除信息头
header = HeaderValue.query.filter(
HeaderValue.env_id == env.env_id).first()
if header is not None:
HeaderValue.query.filter(
HeaderValue.env_id == env.env_id).delete(
synchronize_session=False)
db.session.commit()
db.session.close()
Environment.query.filter(Environment.project_id == project_id).delete(
synchronize_session=False)
db.session.commit()
db.session.close()
return jsonify(common.trueReturn('', '项目删除成功'))
else:
return jsonify(result)
def delete():
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
env_id = request.json.get('env_id')
Environment.query.get_or_404(env_id)
Environment.query.filter_by(env_id=env_id).delete()
db.session.commit()
return jsonify(common.trueReturn('', '接口删除成功'))
else:
return jsonify(result)
def add():
"""
模块接口
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
sceneList = request.json.get("sceneList")
list_sceneEnvData = []
index_num = 1
for sceneEnvData in sceneList['sceneEnvData']:
list_header = []
for headerData in sceneEnvData['headerData']:
herader = HeaderValue(header_name=headerData['header_name'],
header_value=headerData['header_value'])
list_header.append(herader)
list_check = []
check = Check(check_verification_code=sceneEnvData['check_body']
['check_verification_code'],
check_agreement_relation=sceneEnvData['check_body']
['check_agreement_relation'],
check_verification_value=sceneEnvData['check_body']
['check_verification_value'])
list_check.append(check)
variableList = []
for var in sceneEnvData['variableData']:
variable = Variable(var_regexp=var['var_regexp'],
var_name=var['var_name'])
variableList.append(variable)
sceneEnv = SceneEnv(project_id=sceneEnvData['project_id'],
modules_id=sceneEnvData['modules_id'],
env_id=sceneEnvData['env_id'],
scene_body=sceneEnvData['bodyData'],
header=list_header,
check=list_check,
variable=variableList,
number=index_num)
index_num += 1
list_sceneEnvData.append(sceneEnv)
sceneList = SceneList(scene_name=sceneList['scene_name'],
project_id=sceneList['project_id'],
scene_desc=sceneList['scene_desc'],
sceneEnv=list_sceneEnvData)
db.session.add(sceneList)
db.session.commit()
return jsonify(common.trueReturn('', '场景新增成功'))
else:
return jsonify(result)
def selectUpdat():
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
sceneList_id = request.json.get('sceneList_id')
sceneList = SceneList.query.get_or_404(sceneList_id)
sceneJson = {}
sceneJson['scene_name'] = sceneList.scene_name
sceneJson['project_id'] = sceneList.project_id
sceneJson['scene_desc'] = sceneList.scene_desc
sceneEnvData = []
for sceneEnv in sceneList.sceneEnv:
scene = {}
scene['scene_id'] = sceneEnv.scene_id
scene['project_id'] = sceneEnv.project_id
scene['modules_id'] = sceneEnv.modules_id
scene['env_id'] = sceneEnv.env_id
env = Environment.query.filter(
Environment.env_id == sceneEnv.env_id).all()
scene['env_name'] = env[0].env_name
scene['project_name'] = env[0].project.project_name
scene['modules_name'] = env[0].modules.modules_name
scene['bodyData'] = sceneEnv.scene_body
headerData = []
for sceneHeader in sceneEnv.header:
header = {}
header['header_name'] = sceneHeader.header_name
header['header_value'] = sceneHeader.header_value
header['header_id'] = sceneHeader.header_id
headerData.append(header)
scene['headerData'] = headerData
check_body = {}
check_body['check_verification_code'] = sceneEnv.check[
0].check_verification_code
check_body['check_agreement_relation'] = sceneEnv.check[
0].check_agreement_relation
check_body['check_verification_value'] = sceneEnv.check[
0].check_verification_value
scene['check_body'] = check_body
variableData = []
for sceneVariable in sceneEnv.variable:
variable = {}
variable['var_regexp'] = sceneVariable.var_regexp
variable['var_id'] = sceneVariable.var_id
variable['var_name'] = sceneVariable.var_name
variable['var_value'] = sceneVariable.var_value
variableData.append(variable)
scene['variableData'] = variableData
sceneEnvData.append(scene)
sceneJson['sceneEnvData'] = sceneEnvData
return jsonify(common.trueReturn(sceneJson, '查询成功'))
else:
return jsonify(result)
def resume():
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
resumetask(fromData["scheduling_id"])
scheduling = Scheduling.query.get_or_404(fromData['scheduling_id'])
scheduling.scheduling_on = '0'
db.session.commit()
return jsonify(common.trueReturn('', '恢复任务'))
else:
return jsonify(result)
def index():
"""
任务查询
:param page: 页数
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = json.loads(request.args['0'])
page = fromData['page']
param = []
# 拼接查询条件
if fromData['scheduling_title'] != 'None' and len(
fromData['scheduling_title']) > 0:
param.append(
Scheduling.scheduling_title.like("%" +
fromData['scheduling_title'] +
"%"))
# 每页显示数
per_page = current_app.config['INTERFACE_PER_PAGE']
# 分页对象
pagination = Scheduling.query.filter(*param).paginate(
page, per_page=per_page)
# 总条数
count = Scheduling.query.filter(*param).count()
# # 总页数
page_count = math.ceil(count / per_page)
# print('总页数 ', page_count)
# 当前页数的记录列表
schedulingList = pagination.items
scheduling_list = []
for item in schedulingList:
scheduling_dic = {}
scheduling_dic['scheduling_id'] = item.scheduling_id
scheduling_dic['scheduling_title'] = item.scheduling_title
scheduling_dic['scheduling_cron'] = item.scheduling_cron
scheduling_dic['scheduling_on'] = item.scheduling_on
scheduling_dic['email_address'] = item.email_address
scheduling_list.append(scheduling_dic)
list_dic = {}
list_dic['list'] = scheduling_list
list_dic['count'] = count
list_dic['page_count'] = page_count
list_dic['per_page'] = per_page
get_task()
return jsonify(common.trueReturn(list_dic, '任务查询成功'))
else:
return jsonify(result)
def index(page=1):
"""
项目查询
:param page: 页数
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = json.loads(request.args['0'])
param = []
page = fromData['page']
# 拼接查询条件
if fromData['project_name'] != 'None' and len(
fromData['project_name']) > 0:
param.append(
Project.project_name.like("%" + fromData['project_name'] +
"%"))
if fromData['status'] != 'None' and fromData['status'] != '0':
param.append(Project.status == fromData['status'])
# 每页显示数
per_page = current_app.config['INTERFACE_PER_PAGE']
# 分页对象
pagination = Project.query.filter(*param).paginate(page,
per_page=per_page)
# 总条数
count = Project.query.filter(*param).count()
# # 总页数
page_count = math.ceil(count / per_page)
# print('总页数 ', page_count)
# 当前页数的记录列表
project = pagination.items
project_list = []
for item in project:
project_dic = {}
project_dic['project_id'] = item.project_id
project_dic['project_name'] = item.project_name
project_dic['project_desc'] = item.project_desc
project_dic['status'] = item.status
project_list.append(project_dic)
list_dic = {}
list_dic['list'] = project_list
list_dic['count'] = count
list_dic['page_count'] = page_count
list_dic['per_page'] = per_page
return jsonify(common.trueReturn(list_dic, '项目查询成功'))
else:
return jsonify(result)
def getProject():
"""
查询单个项目
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
project_id = request.json.get('project_id')
project = Project.query.get_or_404(project_id)
project_dic = {}
project_dic['project_id'] = project.project_id
project_dic['project_name'] = project.project_name
project_dic['project_desc'] = project.project_desc
project_dic['status'] = project.status
return jsonify(common.trueReturn(project_dic, '查询成功'))
else:
return jsonify(result)
def delete():
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
sceneList_id = request.json.get('sceneList_id')
SceneList.query.filter_by(sceneList_id=sceneList_id).delete()
db.session.commit()
scene_id_All = SceneEnv.query.with_entities(SceneEnv.scene_id).filter(
SceneEnv.sceneList_id == sceneList_id).all()
for scene in scene_id_All:
# 删除数据
checkList = Check.query.filter(
Check.scene_id == scene.scene_id).first()
if checkList is not None:
Check.query.filter(Check.scene_id == scene.scene_id).delete(
synchronize_session=False)
db.session.commit()
headerList = HeaderValue.query.filter(
HeaderValue.scene_id == scene.scene_id).first()
if headerList is not None:
HeaderValue.query.filter(
HeaderValue.scene_id == scene.scene_id).delete(
synchronize_session=False)
db.session.commit()
variableList = Variable.query.filter(
Variable.scene_id == scene.scene_id).first()
if variableList is not None:
Variable.query.filter(
Variable.scene_id == scene.scene_id).delete(
synchronize_session=False)
db.session.commit()
sceneEnvList = SceneEnv.query.filter(
SceneEnv.scene_id == scene.scene_id).first()
if sceneEnvList is not None:
SceneEnv.query.filter(
SceneEnv.scene_id == scene.scene_id).delete(
synchronize_session=False)
db.session.commit()
return jsonify(common.trueReturn('', '场景删除成功'))
else:
return jsonify(result)
def index():
"""
用例查询
:param page: 页数
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = json.loads(request.args['0'])
page = fromData['page']
case_name = fromData['case_name']
param = []
# form = CaseSelectForm()
# case_name = ""
# param = []
# if request.method == 'POST':
# case_name = form.case_name.data
param.append(UserCase.case_name.like("%" + case_name + "%"))
# 每页显示数
per_page = current_app.config['INTERFACE_PER_PAGE']
# 分页对象
pagination = UserCase.query.filter(*param).paginate(page, per_page=per_page)
# 总条数
count = UserCase.query.filter(*param).count()
page_count = math.ceil(count / per_page)
caseList = pagination.items
case_list = []
for item in caseList:
case_dic = {}
case_dic['case_id'] = item.uc_id
case_dic['case_name'] = item.case_name
case_dic['case_desc'] = item.case_desc
case_dic['request_address'] = item.request_address
case_dic['email_address'] = item.email_address
case_list.append(case_dic)
list_dic = {}
list_dic['list'] = case_list
list_dic['count'] = count
list_dic['page_count'] = page_count
list_dic['per_page'] = per_page
return jsonify(common.trueReturn(list_dic, '接口查询成功'))
else:
return jsonify(result)
def getProject():
"""
查询单个模块
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
mod_id = request.json.get('mod_id')
modules = Modules.query.get_or_404(mod_id)
modules_dic = {}
modules_dic['modules_id'] = modules.modules_id
modules_dic['modules_name'] = modules.modules_name
modules_dic['modules_desc'] = modules.modules_desc
modules_dic['project_id'] = modules.project.project_id
modules_dic['status'] = modules.status
return jsonify(common.trueReturn(modules_dic, '查询成功'))
else:
return jsonify(result)
def authenticate(self, username, password):
"""
用户登录，登录成功返回token，写将登录时间写入数据库；登录失败返回失败原因
:param password:
:return: json
"""
admin = Admin.query.filter_by(username=username).first()
if admin is None:
return jsonify(common.falseReturn('', '找不到用户'))
else:
if username == admin.username and admin.validate_password(password):
login_time = int(time.time())
admin.login_time = login_time
db.session.commit()
token = self.encode_auth_token(admin.id, login_time)
return jsonify(common.trueReturn(token.decode(), '登录成功'))
else:
return jsonify(common.falseReturn('', '密码不正确'))
def select_project():
"""
根据项目查询模块
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
project = Project.query.with_entities(Project.project_id,
Project.project_name).all()
project_dict = []
for p, k in project:
pro_json = {}
pro_json['project_id'] = p
pro_json['project_name'] = k
project_dict.append(pro_json)
return jsonify(common.trueReturn(project_dict, '项目查询成功'))
else:
return jsonify(result)
def caseAll():
"""
用例全部查询
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
case = UserCase.query.filter().all()
case_list = []
for item in case:
case_dic = {}
case_dic['case_id'] = item.uc_id
case_dic['case_name'] = item.case_name
case_dic['case_desc'] = item.case_desc
case_dic['request_address'] = item.request_address
case_list.append(case_dic)
list_dic = {}
list_dic['list'] = case_list
return jsonify(common.trueReturn(list_dic, '接口查询成功'))
def delete():
"""
删除Case
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
user_case = UserCase.query.get_or_404(fromData['case_id'])
db.session.delete(user_case)
db.session.commit()
Report.query.filter_by(uc_id=fromData['case_id']).delete(synchronize_session=False)
db.session.commit()
CaseScene.query.filter(CaseScene.uc_id == fromData["case_id"]).delete(synchronize_session=False)
db.session.commit()
return jsonify(common.trueReturn('', '用例删除成功'))
else:
return jsonify(result)
def updateCase():
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
user_case = UserCase.query.get_or_404(fromData['case_id'])
caseJson = {}
caseJson['case_name'] = user_case.case_name
caseJson['case_desc'] = user_case.case_desc
caseJson['case_id'] = user_case.uc_id
caseJson['request_address'] = user_case.request_address
caseJson['email_address'] = user_case.email_address
case_jsonarray = []
for case_env in user_case.case_env:
case_env_dict = {}
case_env_dict['case_id'] = case_env.case_id
case_env_dict['env_id'] = case_env.env_id
env = Environment.query.get_or_404(case_env.env_id)
case_env_dict['env_name'] = env.env_name
case_env_dict['mod_id'] = case_env.modules_id
modules = Modules.query.get_or_404(case_env.modules_id)
case_env_dict['mod_name'] = modules.modules_name
case_env_dict['pro_id'] = case_env.project_id
project = Project.query.get_or_404(case_env.project_id)
case_env_dict['pro_name'] = project.project_name
case_jsonarray.append(case_env_dict)
case_scene_list = []
for case_scene in user_case.caseScene:
case_scene_dict = {}
case_scene_dict['pro_id'] = case_scene.project_id
project = Project.query.get_or_404(case_scene.project_id)
case_scene_dict['pro_name'] = project.project_name
case_scene_dict['scene_id'] = case_scene.sceneList_id
scene_name = SceneList.query.get_or_404(case_scene.caseScene_id)
case_scene_dict['scene_name'] = scene_name.scene_name
case_scene_list.append(case_scene_dict)
caseJson['case_env_list'] = json.dumps(case_jsonarray, ensure_ascii=False)
caseJson['case_scene_list'] = json.dumps(case_scene_list, ensure_ascii=False)
return jsonify(common.trueReturn(caseJson, '用例查询成功'))
else:
return jsonify(result)
def select_modular():
"""
根据项目查询场景
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = json.loads(request.args['0'])
project_id = fromData['project_id']
model = SceneList.query.with_entities(
SceneList.sceneList_id, SceneList.scene_name).filter(
SceneList.project_id == project_id).all()
sceneList_dict = []
for p, k in model:
sceneList_json = {}
sceneList_json['sceneList_id'] = p
sceneList_json['scene_name'] = k
sceneList_dict.append(sceneList_json)
return jsonify(common.trueReturn(sceneList_dict, '场景查询成功'))
else:
return jsonify(result)
def select_modular():
"""
根据项目查询模块
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = json.loads(request.args['0'])
project_id = fromData['project_id']
model = Modules.query.with_entities(
Modules.modules_id, Modules.modules_name).filter(
Modules.project_id == project_id).all()
model_dict = []
for p, k in model:
model_json = {}
model_json['modules_id'] = p
model_json['modules_name'] = k
model_dict.append(model_json)
return jsonify(common.trueReturn(model_dict, '模块查询成功'))
else:
return jsonify(result)
def select_env():
"""
根据模块查询接口
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = json.loads(request.args['0'])
modules_id = fromData['modules_id']
env = Environment.query.with_entities(
Environment.env_id, Environment.env_name).filter(
Environment.modules_id == modules_id).all()
env_dict = []
for p, k in env:
env_json = {}
env_json['env_id'] = p
env_json['env_name'] = k
env_dict.append(env_json)
return jsonify(common.trueReturn(env_dict, '接口查询成功'))
else:
return jsonify(result)
def delete():
"""
删除任务
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
fromData = request.json
Scheduling.query.filter_by(
scheduling_id=fromData["scheduling_id"]).delete(
synchronize_session=False)
db.session.commit()
TaskCase.query.filter(
TaskCase.scheduling_id == fromData["scheduling_id"]).delete(
synchronize_session=False)
db.session.commit()
get_task()
print(fromData["scheduling_id"])
remove_task(fromData["scheduling_id"])
return jsonify(common.trueReturn('', '删除成功'))
else:
return jsonify(result)
def add():
"""
项目新增
:return:
"""
result = Auth.identify(Auth, request)
if result['status'] and result['data']:
project_name = request.json.get('project_name')
project_desc = request.json.get('project_desc')
status = request.json.get('status')
if status:
status = '1'
else:
status = '2'
project = Project(project_name=project_name,
project_desc=project_desc,
status=status)
db.session.add(project)
db.session.commit()
return jsonify(common.trueReturn('', '项目新增成功'))
else:
return jsonify(result)
