def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(add_model_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
project_id = data.get('project_id')
model_name = data.get('model_name')
model_desc = data.get('model_desc')
exist_project = Project.query.filter_by(id=project_id,
status=True).first()
if not exist_project:
res.update(code=-1, data='', msg=project_not_exist_error)
return jsonify(res.data)
model_desc = model_desc if model_desc else ''
new_model = Model(model_name=model_name,
model_desc=model_desc,
project_id=project_id,
c_uid=current_user.id)
db.session.add(new_model)
try:
db.session.commit()
model_info = {
'model_id': new_model.id,
'model_name': model_name,
'create_user': current_user.id,
}
res.update(code=1, data=model_info, msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(mf_list_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
page_num = data.get('page_num')
page_size = data.get('page_size', 10)
mf_list = list()
try:
mfs = Manufacturer.query.filter_by(status=1).all()
except Exception as e:
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
if mfs:
for mf in mfs:
mf_info = {
'mf_id': mf.id,
'mf_name': mf.name,
}
mf_list.append(mf_info)
data, total = list_page(mf_list, page_size, page_num)
res.update(code=1, data=data, msg=request_success)
res.add_field(name='page_total_num', value=total)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(add_model_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
model_id = data.get('model_id')
model_name = data.get('model_name')
model_desc = data.get('model_desc')
exist_model = Model.query.filter_by(id=model_id, status=True).first()
if not exist_model:
res.update(code=-1, data='', msg=model_not_exist_error)
return jsonify(res.data)
model_desc = model_desc if model_desc else ''
exist_model.model_name = model_name
exist_model.model_desc = model_desc
try:
db.session.commit()
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(model_list_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
project_id = data.get('project_id')
page_num = data.get('page_num')
page_size = data.get('page_size', 10)
model_list = list()
try:
models = Model.query.filter_by(project_id=project_id,
status=True).order_by(
Model.id.desc()).all()
except Exception as e:
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
if models:
for m in models:
model_info = {
'model_id': m.id,
'model_name': m.model_name,
'create_user': m.users.username,
}
model_list.append(model_info)
data, total = list_page(model_list, page_size, page_num)
res.update(code=1, data=data, msg=request_success)
res.add_field(name='page_total_num', value=total)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(env_list_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
page_num = data.get('page_num')
page_size = data.get('page_size', 10)
env_list = list()
try:
environments = Environment.query.filter_by(status=True).order_by(
Environment.id.desc()).all()
except Exception as e:
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
if environments:
for env in environments:
env_info = {
'env_id': env.id,
'env_name': env.env_name,
'url': env.url,
'create_user': env.users.username,
}
env_list.append(env_info)
data, total = list_page(env_list, page_size, page_num)
res.update(code=1, data=data, msg=request_success)
res.add_field(name='page_total_num', value=total)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(del_eq_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
eq_id = data.get('eq_id')
exist_eq = Equipment.query.filter_by(id=eq_id, status=1).first()
if not exist_eq:
res.update(code=-1, data='', msg=eq_not_exist_error)
return jsonify(res.data)
exist_eq.status = 0
try:
db.session.commit()
eq_info = {
'eq_code': exist_eq.eq_code,
'eq_name': exist_eq.eq_name,
'eq_desc': exist_eq.eq_desc,
'eq_type': exist_eq.eq_type,
'eq_sys': exist_eq.eq_sys,
'eq_sys_ver': exist_eq.eq_sys_ver,
'eq_owner': exist_eq.eq_owner,
'borrower': exist_eq.borrower,
'have_sim': exist_eq.have_sim,
'mf_id': exist_eq.mf_id,
'eq_id': exist_eq.id
}
add_eq_log(eq_info, 5)
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(eq_list_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
page_num = data.get('page_num')
page_size = data.get('page_size', 10)
eq_list = list()
try:
equip = Equipment.query.filter_by(status=1).order_by(Equipment.id.desc()).all()
except Exception as e:
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
if equip:
for eq in equip:
eq_info = {
'eq_id': eq.id,
'eq_code': eq.eq_code,
'eq_name': eq.eq_name,
'eq_type': eq.eq_type,
'eq_sys': eq.eq_sys,
'eq_sys_ver': eq.eq_sys_ver,
'eq_owner': eq.eq_owner,
'borrower': eq.borrower,
'have_sim': eq.have_sim,
'eq_status': eq.eq_status,
'mf_name': eq.manufacturers.name,
}
eq_list.append(eq_info)
data, total = list_page(eq_list, page_size, page_num)
res.update(code=1, data=data, msg=request_success)
res.add_field(name='page_total_num', value=total)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(edit_interface_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
interface_id = data.get('interface_id')
interface_name = data.get('interface_name')
interface_desc = data.get('interface_desc')
interface_type = data.get('interface_type')
method = data.get('method')
path = data.get('path')
exist_interface = Interface.query.filter_by(id=interface_id,
status=True).first()
if not exist_interface:
res.update(code=-1, data='', msg=interface_not_exist_error)
return jsonify(res.data)
exist_interface.Interface_name = interface_name
exist_interface.Interface_desc = interface_desc
exist_interface.interface_type = interface_type
exist_interface.method = method
exist_interface.path = path
try:
db.session.commit()
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(duplicate_case_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
case_id = data.get('case_id')
exist_case = TestCase.query.filter_by(id=case_id, status=True).first()
if not exist_case:
res.update(code=-1, data='', msg=case_not_exist_error)
return jsonify(res.data)
new_case = TestCase(
case_name=exist_case.case_name,
case_desc=exist_case.case_desc,
case_type=exist_case.case_type,
method=exist_case.method,
path=exist_case.path,
params=exist_case.params,
header=exist_case.header,
has_sign=exist_case.has_sign,
ak=exist_case.ak,
sk=exist_case.sk,
res_assert=exist_case.res_assert,
rely_params=exist_case.rely_params,
has_output=exist_case.has_output,
output_para=exist_case.output_para,
has_input=exist_case.has_input,
input_para=exist_case.input_para,
input_header=exist_case.input_header,
save_result=exist_case.save_result,
use_db=exist_case.use_db,
sql=exist_case.sql,
field_value=exist_case.field_value,
project_id=exist_case.project_id,
model_id=exist_case.model_id,
interface_id=exist_case.interface_id,
env_id=exist_case.env_id,
c_uid=current_user.id
)
db.session.add(new_case)
db.session.flush()
for exist_rc in exist_case.rely_case.all():
new_case.rely_case.append(exist_rc)
try:
db.session.commit()
case_info = {
'case_id': new_case.id,
'case_name': new_case.case_name,
}
res.update(code=1, data=case_info, msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(run_multiple_case_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
project_id = data.get('project_id')
case_list = data.get('case_list')
day = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
task_name = "执行用例任务_%s" % day
# project = Project.query.filter_by(id=project_id, status=True).first()
# if not project:
# res.update(code=-1, data='', msg=project_not_exist_error)
# return jsonify(res.data)
new_task = Task(
task_name=task_name,
task_type=0,
run_time='',
run_status=1,
c_uid=current_user.id,
s_uid=current_user.id,
project_id=project_id,
)
db.session.add(new_task)
db.session.flush()
add_case_list, err_case_list, debug_case_list = [[], [], []]
for case_id in case_list:
exist_case = TestCase.query.filter_by(id=case_id, status=True).first()
if exist_case:
if not exist_case.is_debug:
debug_case_list.append(case_id)
continue
new_task.interface.append(exist_case)
add_case_list.append(case_id)
else:
err_case_list.append(case_id)
case_info = {
'add_case': add_case_list,
'err_case': err_case_list,
'debug_case': debug_case_list,
}
if len(add_case_list) == 0:
db.session.rollback()
res.update(code=-1, data=case_info, msg=task_add_case_error)
return jsonify(res.data)
try:
db.session.commit()
run_task(new_task.id, current_user.id, day)
res.update(code=1, data=case_info, msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(add_env_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
env_name = data.get('env_name')
desc = data.get('desc')
url = data.get('url')
use_db = data.get('use_db')
db_host = data.get('db_host')
db_port = data.get('db_port')
db_user = data.get('db_user')
db_pass = data.get('db_pass')
database = data.get('database')
desc = desc if desc else ''
use_db = True if use_db == 1 else False
db_host = db_host if db_host else ''
db_port = db_port if db_port else ''
db_user = db_user if db_user else ''
db_pass = db_pass if db_pass else ''
database = database if database else ''
if use_db:
if db_host and db_port and db_user and db_pass and database:
pass
else:
res.update(code=-1, data='', msg=db_info_empty_error)
return jsonify(res.data)
else:
db_host = db_port = db_user = db_pass = database = ''
new_env = Environment(env_name=env_name,
desc=desc,
url=url,
use_db=use_db,
db_host=db_host,
db_port=db_port,
db_user=db_user,
db_pass=db_pass,
database=database,
c_uid=current_user.id)
db.session.add(new_env)
try:
db.session.commit()
env_info = {
'env_id': new_env.id,
'env_name': env_name,
}
res.update(code=1, data=env_info, msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(add_eq_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
eq_code = data.get('eq_code')
eq_name = data.get('eq_name')
eq_desc = data.get('eq_desc')
eq_type = data.get('eq_type')
eq_sys = data.get('eq_sys')
eq_sys_ver = data.get('eq_sys_ver')
eq_owner = data.get('eq_owner')
have_sim = data.get('have_sim')
mf_id = data.get('mf_id')
exist_eq = Equipment.query.filter_by(eq_code=eq_code, status=1).first()
if exist_eq:
res.update(code=-1, data='', msg=eq_code_exist_error)
return jsonify(res.data)
new_eq = Equipment(
eq_code=eq_code,
eq_name=eq_name,
eq_desc=eq_desc,
eq_type=eq_type,
eq_sys=eq_sys,
eq_sys_ver=eq_sys_ver,
eq_owner=eq_owner,
have_sim=have_sim,
mf_id=mf_id
)
db.session.add(new_eq)
try:
db.session.commit()
eq_info = {
'eq_code': eq_code,
'eq_name': eq_name,
'eq_desc': eq_desc,
'eq_type': eq_type,
'eq_sys': eq_sys,
'eq_sys_ver': eq_sys_ver,
'eq_owner': eq_owner,
'borrower': '',
'have_sim': have_sim,
'mf_id': mf_id,
'eq_id': new_eq.id
}
add_eq_log(eq_info, 1)
res.update(code=1, data=eq_info, msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(eq_info_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
eq_id = data.get('eq_id')
exist_eq = Equipment.query.filter_by(id=eq_id, status=1).first()
if not exist_eq:
res.update(code=-1, data='', msg=eq_not_exist_error)
return jsonify(res.data)
eq_info = {
'eq_id': exist_eq.id,
'eq_code': exist_eq.eq_code,
'eq_name': exist_eq.eq_name,
'eq_desc': exist_eq.eq_desc,
'eq_type': exist_eq.eq_type,
'eq_sys': exist_eq.eq_sys,
'eq_sys_ver': exist_eq.eq_sys_ver,
'eq_owner': exist_eq.eq_owner,
'borrower': exist_eq.borrower,
'have_sim': exist_eq.have_sim,
'eq_status': exist_eq.eq_status,
'mf_id': exist_eq.mf_id,
}
res.update(code=1, data=eq_info, msg=request_success)
return jsonify(res.data)
def post(self):
# 返回
res = ResMsg()
# 获取请求数据
data = request.get_json()
product_id = data.get("product_id")
module_id = data.get("module_id")
report_product = ReportProduct.query.filter_by(
product_id=product_id, module_id=module_id).first()
if report_product:
try:
ReportProduct.query.filter_by(product_id=product_id,
module_id=module_id).delete()
ReportUser.query.filter_by(product_id=product_id,
module_id=module_id).delete()
ReportDay.query.filter_by(product_id=product_id,
module_id=module_id).delete()
db.session.commit()
res.update(code=1, data='', msg='删除成功！')
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data='', msg='删除失败！' + str(e))
return jsonify(res.data)
else:
res.update(code=1, data='', msg='删除失败，请检查信息！')
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(env_info_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
env_id = data.get('env_id')
exist_env = Environment.query.filter_by(id=env_id, status=True).first()
if not exist_env:
res.update(code=-1, data='', msg=env_not_exist_error)
return jsonify(res.data)
use_db = 1 if exist_env.use_db else 0
env_info = {
'env_id': exist_env.id,
'env_name': exist_env.env_name,
'desc': exist_env.desc,
'url': exist_env.url,
'use_db': use_db,
'db_host': exist_env.db_host,
'db_port': exist_env.db_port,
'db_user': exist_env.db_user,
'db_pass': exist_env.db_pass,
'database': exist_env.database,
'create_user': exist_env.users.username,
}
res.update(code=1, data=env_info, msg=request_success)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(mock_info_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
mock_id = data.get('mock_id')
exist_mock = Mock.query.filter_by(id=mock_id, status=True).first()
if not exist_mock:
res.update(code=-1, data='', msg=mock_not_exist_error)
return jsonify(res.data)
mock_info = {
'mock_id': exist_mock.id,
'mock_name': exist_mock.mock_name,
'mock_desc': exist_mock.mock_desc,
'method': exist_mock.method,
'path': exist_mock.path,
'params': exist_mock.params,
'header': exist_mock.header,
'response': exist_mock.response,
'res_type': exist_mock.res_type,
'update_time': exist_mock.update_time,
'run_status': exist_mock.run_status,
'check_params': exist_mock.check_params,
'check_header': exist_mock.check_header,
'create_user': exist_mock.users.username,
}
res.update(code=1, data=mock_info, msg=request_success)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(edd_param_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
interface_id = data.get('interface_id')
Parameter.query.filter_by(interface_id=interface_id).delete(
synchronize_session=False)
params = data.get('params')
if len(params) > 0:
for para in params:
new_param = Parameter(
param_name=para.get('param_name'),
param_desc=para.get('param_desc'),
necessary=True if para.get('is_necessary') == 1 else False,
default=para.get('default'),
interface_id=interface_id,
c_uid=current_user.id)
db.session.add(new_param)
try:
db.session.commit()
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(import_json_data_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
project_id = data.get('project_id')
model_id = data.get('model_id')
file_name = data.get('file_name')
json_type = data.get('json_type')
flag, data_list = ImportJson(file_name).get_data_list(json_type)
if flag == -1:
res.update(code=-1, data=data_list, msg=open_file_error)
return jsonify(res.data)
for data in data_list:
new_interface = Interface(Interface_name=data['interface_name'],
Interface_desc=data['interface_desc'],
interface_type=data['interface_type'],
method=data['method'],
path=data['path'],
header=data['header'],
response=data['response'],
project_id=project_id,
model_id=model_id,
c_uid=current_user.id)
db.session.add(new_interface)
db.session.flush()
if len(data['params']) > 0:
for para in data['params']:
new_param = Parameter(param_name=para['param_name'],
param_desc=para['param_desc'],
necessary=para['necessary'],
default=para['default'],
interface_id=new_interface.id,
c_uid=current_user.id)
db.session.add(new_param)
try:
db.session.commit()
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(statistics_task_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
password = data.get('password')
if password != 'za-test':
res.update(code=-1, data='', msg=password_error)
return jsonify(res.data)
job_name = 'case_statistics_%s' % password
if sched.get_job(job_name):
sched.remove_job(job_name)
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
else:
mes = {'error': '缓存中不存在任务 %s 信息' % job_name}
res.update(code=-1, data=mes, msg=task_stop_error)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(del_case_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
case_id = data.get('case_id')
exist_case = TestCase.query.filter_by(id=case_id, status=True).first()
if not exist_case:
res.update(code=-1, data='', msg=case_not_exist_error)
return jsonify(res.data)
exist_case.status = False
try:
db.session.commit()
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def get(self):
res = ResMsg()
day = 7
case_stat = CaseStatistics.query.order_by(
CaseStatistics.id.desc()).limit(day)
if case_stat.count() == 0:
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
new_cs = case_stat.first()
cs_date_list = []
for cs in reversed(case_stat.all()):
date_cs = {
'open_date': cs.open_date,
'today_run_case_num': cs.today_run_case_num,
'today_suc_case_num': cs.today_suc_case_num,
'today_fail_case_num': cs.today_fail_case_num,
}
cs_date_list.append(date_cs)
data = {
'interface_num': new_cs.interface_num,
'case_num': new_cs.case_num,
'run_case_num': new_cs.run_case_num,
'success_case_num': new_cs.success_case_num,
'failure_case_num': new_cs.failure_case_num,
'exception_case_num': new_cs.exception_case_num,
'cs_date_list': cs_date_list
}
res.update(code=1, data=data, msg=request_success)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(UserInfoByXid_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
xid = data.get('xid')
data = get_user_info_by_xid(xid)
pager = Pager(data)
data = pager.page_data()
res.update(code=1, data=data, msg=request_success)
res.add_field(name='data_total', value=pager.data_count)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(add_mf_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
mf_name = data.get('mf_name')
exist_mf = Manufacturer.query.filter_by(name=mf_name, status=1).first()
if exist_mf:
res.update(code=-1, data='', msg=mf_name_exist)
return jsonify(res.data)
new_eq = Manufacturer(name=mf_name)
db.session.add(new_eq)
try:
db.session.commit()
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(change_pass_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
password = data.get('password')
set_password = data.get('set_password')
if password != set_password:
res.update(code=-1, data='', msg=password_not_same)
return jsonify(res.data)
users = User.query.filter_by(id=current_user.id).first()
users.set_password(password)
try:
db.session.commit()
res.update(code=1, data='', msg=change_password_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=change_password_failure)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(interface_info_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
interface_id = data.get('interface_id')
exist_interface = Interface.query.filter_by(id=interface_id,
status=True).first()
if not exist_interface:
res.update(code=-1, data='', msg=interface_not_exist_error)
return jsonify(res.data)
project_name = exist_interface.projects.project_name if exist_interface.project_id else ''
model_name = exist_interface.models.model_name if exist_interface.model_id else ''
params = Parameter.query.filter_by(interface_id=interface_id,
status=True).all()
param_list = list()
if params:
for p in params:
is_necessary = 1 if p.necessary else 0
param_info = {
'param_id': p.id,
'param_name': p.param_name,
'param_desc': p.param_desc,
'is_necessary': is_necessary,
'default': p.default,
}
param_list.append(param_info)
header = json.loads(
exist_interface.header) if exist_interface.header else {}
response = exist_interface.response if exist_interface.response else ''
interface_info = {
'interface_id': exist_interface.id,
'interface_name': exist_interface.Interface_name,
'interface_desc': exist_interface.Interface_desc,
'interface_type': exist_interface.interface_type,
'method': exist_interface.method,
'path': exist_interface.path,
'header': header,
'params': param_list,
'response': response,
'project_name': project_name,
'model_name': model_name,
'create_user': exist_interface.users.username,
}
res.update(code=1, data=interface_info, msg=request_success)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(case_res_info_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
case_result_id = data.get('case_result_id')
case_result = CaseResult.query.filter_by(id=case_result_id).first()
if not case_result:
res.update(code=-1, data='', msg=case_res_not_exist_error)
return jsonify(res.data)
exist_case = TestCase.query.filter_by(id=case_result.case_id, status=True).first()
if not exist_case:
res.update(code=-1, data='', msg=case_not_exist_error)
return jsonify(res.data)
case_info = {
'case_result_id': case_result.id,
'case_name': exist_case.case_name,
'case_type': case_result.case_type,
'method': case_result.method,
'path': case_result.path,
'params': case_result.params,
'input_para': case_result.input_para,
'header': case_result.header,
'input_header': case_result.input_header,
'aksk_header': case_result.aksk_header,
'res_assert': case_result.res_assert,
'case_result': case_result.case_result,
'response': case_result.response,
'output_para': case_result.output_para,
'diff_res': case_result.diff_res,
'start_time': datetime.datetime.strftime(case_result.start_time, "%Y-%m-%d %H:%M:%S"),
'duration': case_result.duration,
'task_name': case_result.tasks.task_name if case_result.task_id else '',
}
res.update(code=1, data=case_info, msg=request_success)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(pro_list_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
project_name = data.get('project_name')
page_num = data.get('page_num')
page_size = data.get('page_size', 10)
project_list = list()
try:
projects = Project.query.filter_by(status=True).order_by(
Project.id.desc()).all()
except Exception as e:
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
if projects:
for p in projects:
if project_name:
if project_name in p.project_name:
project_info = {
'project_id': p.id,
'project_name': p.project_name,
'create_user': p.users.username,
}
project_list.append(project_info)
else:
project_info = {
'project_id': p.id,
'project_name': p.project_name,
'create_user': p.users.username,
}
project_list.append(project_info)
data, total = list_page(project_list, page_size, page_num)
res.update(code=1, data=data, msg=request_success)
res.add_field(name='page_total_num', value=total)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(mock_info_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
mock_id = data.get('mock_id')
exist_mock = Mock.query.filter_by(id=mock_id, status=True).first()
if not exist_mock:
res.update(code=-1, data='', msg=mock_not_exist_error)
return jsonify(res.data)
if exist_mock.run_status == 0:
exist_mock.run_status = 1
else:
exist_mock.run_status = 0
try:
db.session.commit()
res.update(code=1, data='', msg=request_success)
return jsonify(res.data)
except Exception as e:
db.session.rollback()
res.update(code=-1, data=str(e), msg=request_fail)
return jsonify(res.data)
def post(self):
res = ResMsg()
data = request.get_json()
flag, mes = format_checker(test_statistics_schema, data)
if not flag:
res.update(code=-1, data=mes, msg=param_format_error)
return jsonify(res.data)
password = data.get('password')
day = data.get('day')
save = data.get('save')
if password != 'za-test':
res.update(code=-1, data='', msg=password_error)
return jsonify(res.data)
save = True if save == 1 else False
data = case_data_statistics(day, save)
res.update(code=1, data=data, msg=request_success)
return jsonify(res.data)
def get(self):
# 返回
res = ResMsg()
product_list = []
# 要返回的形式 [product_list:[{id:1,name:1}]]
try:
report_product_list = ReportProduct.query.filter().order_by(
ReportProduct.id.desc()).all()
product_info = {}
for pi in report_product_list:
module_list = []
if product_info.get('id') is None:
module_info = {
'id': pi.module_id,
'name': pi.module_name,
}
module_list.append(module_info)
product_info = {
'id': pi.product_id,
'name': pi.product_name,
'module_list': module_list
}
try:
report_product_list = ReportProduct.query.filter(
ReportProduct.product_id == pi.product_id).order_by(
ReportProduct.id.desc()).all()
for i in report_product_list:
if i.module_id != pi.module_id:
module_info = {
'id': i.module_id,
'name': i.module_name
}
module_list.append(module_info)
except Exception as e:
res.update(code=-1, data='', msg='获取失败！' + str(e))
return jsonify(res.data)
product_list.append(product_info)
res.update(code=1, data=product_list, msg='sucess！')
return jsonify(res.data)
except Exception as e:
res.update(code=-1, data='', msg='获取失败！' + str(e))
return jsonify(res.data)
