def post(self):
name = request.data.decode('utf-8')
if current_user.is_sper == False:
return reponse(message=MessageEnum.user_not_permision.value[1],
code=MessageEnum.user_not_permision.value[0])
if name == '':
return reponse(code=MessageEnum.project_cannot_empty.value[0],
message=MessageEnum.project_cannot_empty.value[1])
projec = Project.query.filter_by(project_name=name,
status=False).first()
if projec:
return reponse(code=MessageEnum.project_only_one.value[0],
message=MessageEnum.project_only_one.value[1])
new_moel = Project(project_name=name, project_user_id=current_user.id)
try:
db.session.add(new_moel)
db.session.commit()
# testgroup = TestGroup(adduser=current_user.id,
# addtime=datetime.datetime.now(),
# updatetime=datetime.datetime.now(),
# updateuser=current_user.id,
# name='黑名单', projectid=new_moel.id)
# db.session.add(testgroup)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(code=MessageEnum.project_add_error.value[0],
message=MessageEnum.project_add_error.value[1])
def post(self):
id = request.get_data('id')
project = id.decode('utf-8')
if not project:
return reponse(message=MessageEnum.error_send_message.value[1],
code=MessageEnum.error_send_message.value[0],
data='')
project_is = Project.query.filter_by(project_name=project).first()
if not project_is:
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0],
data=[])
testreport = TestResult.query.filter_by(
projects_id=project_is.id,
status=False).order_by(TestResult.id.desc()).all()
testreportlist = []
for test in testreport:
testreportlist.append({
'test_num': test.test_num,
'pass_num': test.pass_num,
'fail_num': test.fail_num,
'hour_time': str(test.hour_time),
'test_rep': test.test_rep,
'test_log': test.test_log,
'Exception_num': test.Exception_num,
'can_num': test.can_num,
'wei_num': test.wei_num,
'test_time': str(test.test_time),
'Test_user_id': test.users.username,
'id': test.id,
'fenshu': test.pass_num / test.test_num
})
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0],
data=(testreportlist))
def getprojects(): # 获取项目
id = request.get_data('id')
if not id:
return reponse(message=MessageEnum.request_null_message.value[1],
code=MessageEnum.request_null_message.value[0],
data={})
peoject = InterfaceTest.query.filter_by(id=int(id)).first()
result = peoject.projects
projetc = Project.query.filter_by(
project_name=str(result.project_name)).first()
testhuanjing = Interfacehuan.query.filter_by(projects=projetc,
status=False).all()
if len(testhuanjing) <= 0:
return reponse(code=MessageEnum.testeveirment_not_exict.value[0],
message=MessageEnum.testeveirment_not_exict.value[1],
data={})
url_list = []
for huanjing in testhuanjing:
url_list.append(huanjing.url)
if not peoject:
return reponse(code=MessageEnum.project_not_exict.value[0],
message=MessageEnum.project_not_exict.value[1],
data="")
data = {}
data['project'] = result.project_name
data['url'] = url_list
return reponse(data=data,
code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
def put(self):
data = request.data.decode('utf-8')
json_data = json.loads(data)
id = json_data['id']
name = json_data['name']
projec = json_data['project']
edit_mode = Model.query.filter_by(id=id, status=False).first()
if projec == '请选择':
project_one = None
else:
project_one = Project.query.filter_by(
status=False, project_name=projec).first().id
if not edit_mode:
mew = Model(model_name=name, model_user_id=current_user.id)
db.session.add(mew)
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
edit_mode.model_name = name
edit_mode.project = project_one
try:
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(message=MessageEnum.edit_model_error.value[1],
code=MessageEnum.edit_model_error.value[0])
def post(self):
data = request.get_json()
project = data['project']
model = data['model']
name = data['name']
url = data['url']
headers = data['headers']
xieyi = data['xieyi']
meth = data['meth']
project_id = Project.query.filter_by(project_name=project).first().id
models_id = Model.query.filter_by(model_name=model).first().id
try:
new_interface = Interface(model_id=models_id,
projects_id=project_id,
Interface_name=name,
Interface_url=url,
Interface_meth=meth,
Interface_user_id=current_user.id,
Interface_headers=headers,
interfacetype=xieyi)
db.session.add(new_interface)
db.session.commit()
return reponse(message=MessageEnum.interface_add_success.value[1],
code=MessageEnum.interface_add_success.value[0])
except Exception as e:
logger.error(e)
db.session.rollback()
return reponse(message=MessageEnum.interface_add_erroe.value[1],
code=MessageEnum.interface_add_erroe.value[0],
data='')
def post(self):
data = request.get_json()
models = Model.query.filter_by(model_name=data['name']).first()
if data['project'] == '请选择':
# common = True
project_one = None
else:
project_one = Project.query.filter_by(
project_name=data['project']).first().id
# common = False
if models:
return reponse(code=MessageEnum.model_only_one.value[0],
message=MessageEnum.model_only_one.value[1])
new_moel = Model(model_name=data['name'],
model_user_id=current_user.id,
project=project_one)
db.session.add(new_moel)
try:
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
except Exception as e:
logger.error(e)
db.session.rollback()
return reponse(code=MessageEnum.model_edit_fial.value[0],
message=MessageEnum.model_edit_fial.value[1])
def get(self, interfaceid):
interface_one = Interface.query.filter_by(id=interfaceid,
status=False).first()
if not interface_one:
return reponse(message=MessageEnum.Interface_not_exict.value[1],
code=MessageEnum.Interface_not_exict.value[0])
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
def delete(self):
data = request.data.decode('utf-8')
ded = Mockserver.query.filter_by(id=data, status=False).first()
if ded:
ded.delete = True
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
return reponse(message=MessageEnum.delete_mock_error.value[1],
code=MessageEnum.delete_mock_error.value[0])
def delete(self):
data = request.data.decode('utf-8')
event = Interfacehuan.query.filter_by(id=data).first()
event.status = True
try:
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
except Exception as e:
logger.error(e)
return reponse(message=MessageEnum.delete_fail.value[1],
code=MessageEnum.delete_fail.value[0])
def post(self):
password = request.data.decode('utf-8')
user = User.query.filter_by(username=session.get('username')).first()
user.set_password(password)
try:
db.session.commit()
return reponse(code=MessageEnum.change_password_success.value[0],
data=MessageEnum.change_password_success.value[1])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(code=MessageEnum.change_password_error.value[0],
data=MessageEnum.change_password_error.value[1])
def put(self):
data = request.get_json()
id = Action.query.filter_by(id=data['id']).first()
if not id:
return reponse(code=MessageEnum.re_editisnot.value[0],
message=MessageEnum.re_editisnot.value[1])
if data['type'] == "0":
id.sleepnum = int(data['num'])
id.style = 0
db.session.commit()
return reponse(code=MessageEnum.re_editisnot.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == "1":
testevnet = Interfacehuan.query.filter_by(
id=int(data['eventid'])).first()
if not testevnet:
return reponse(
code=MessageEnum.testeveirment_not_exict.value[0],
message=MessageEnum.testeveirment_not_exict.value[1])
id.testevent = testevnet
id.style = 1
id.sql = data['sql']
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == "2":
id.style = 2
testevnet = Interfacehuan.query.filter_by(
id=int(data['eventid'])).first()
if not testevnet:
return reponse(
code=MessageEnum.testeveirment_not_exict.value[0],
message=MessageEnum.testeveirment_not_exict.value[1])
case_is = InterfaceTest.query.filter_by(
id=int(data['caseid'])).first()
if not case_is:
return reponse(code=MessageEnum.case_not_exict.value[0],
message=MessageEnum.case_not_exict.value[1])
id.testevent = testevnet
id.caseid = case_is.id
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == "3":
id.style = 3
id.requestsurl = data['url']
id.requestmethod = data['method']
id.requestsparame = data['parame']
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
else:
return reponse(code=MessageEnum.re_is_not_exitc.value[0],
message=MessageEnum.re_is_not_exitc.value[1],
data='')
def delete(self):
data = request.data.decode('utf-8')
testcase = InterfaceTest.query.filter_by(id=data).first()
if not testcase:
return reponse(data=MessageEnum.case_not_exict.value[1],
code=MessageEnum.case_not_exict.value[0])
try:
testcase.status = True
db.session.commit()
return reponse(data=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.error(e)
db.session.rollback()
return reponse(data=MessageEnum.delete_case_error.value[1],
code=MessageEnum.delete_case_error.value[0])
def delete(self):
data = request.data.decode('utf-8')
model = Model.query.filter_by(id=data, status=False).first()
if not model:
return reponse(message=MessageEnum.model_not_exict.value[1],
code=MessageEnum.model_not_exict.value[0])
model.status = True
try:
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.error(e)
db.session.rollback()
return reponse(message=MessageEnum.delete_fail.value[1],
code=MessageEnum.delete_fail.value[0])
def delete(self):
data = request.data.decode('utf-8')
interface = Interface.query.filter_by(id=data, status=False).first()
if not interface:
return reponse(message=MessageEnum.interface_add_not.value[1],
code=MessageEnum.interface_add_not.value[0])
interface.status = True
try:
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.info(e)
db.session.rollback()
return reponse(message=MessageEnum.delete_inteface_error.value[1],
code=MessageEnum.delete_inteface_error.value[0])
def put(self):
data = request.get_json()
json_data = data
project = json_data['project']
id = json_data['id']
url = json_data['url']
desc = json_data['desc']
name = json_data['name']
host = json_data['host']
port = json_data['port']
usernmae = json_data['username']
password = json_data['password']
project = Project.query.filter_by(project_name=project).first()
event = Interfacehuan.query.filter_by(id=id).first()
if not event:
newevent = Interfacehuan(url=url,
desc=desc,
project=project.id,
database=name,
databaseuser=usernmae,
databasepassword=password,
dbhost=host,
dbport=port,
make_user=current_user.id)
db.session.add(newevent)
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
event.url = url
event.desc = desc
event.database = name
event.databaseuser = usernmae
event.datebasepassword = password
event.dbhost = host
event.dbport = port
event.project = project.id
event.make_user = current_user.id
try:
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(message=MessageEnum.edit_mock_error.value[1],
code=MessageEnum.edit_mock_error.value[0])
def delete(self):
data = request.data.decode('utf-8')
delTest = TestResult.query.filter_by(id=data, status=False).first()
if not delTest:
return reponse(
message=MessageEnum.delete_report_not_exict.value[1],
code=MessageEnum.delete_report_not_exict.value[0])
delTest.status = True
try:
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(message=MessageEnum.delete_report_fail.value[1],
code=MessageEnum.delete_report_fail.value[0])
def post(self):
data = request.get_json()
task_time = {
'type': 'cron',
'day_of_week': data['week'],
'hour': data['hour'],
'minute': data['minx']
}
taskname_is = Task.query.filter_by(taskname=data['taskname']).first()
testevent = Interfacehuan.query.filter_by(
url=data['testevent']).first()
if not testevent:
return reponse(code=MessageEnum.task_event_not_exict.value[0],
message=MessageEnum.task_event_not_exict.value[1],
data='')
if taskname_is:
return reponse(code=MessageEnum.task_name_not_same.value[0],
message=MessageEnum.task_name_not_same.value[1],
data='')
procjt = Project.query.filter_by(project_name=data['projects'],
status=False).first()
if not procjt:
return reponse(
code=MessageEnum.task_project_is_not_exict.value[0],
message=MessageEnum.task_project_is_not_exict.value[1],
data='')
new_task = Task(taskname=data['taskname'],
taskstart=str(task_time),
taskrepor_to=data['to_email'],
taskrepor_cao=data['cao_email'],
task_make_email=data['weihu'],
makeuser=current_user.id,
prject=procjt.id,
testevent=testevent.id)
db.session.add(new_task)
try:
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1],
data='')
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(code=MessageEnum.task_add_fail.value[0],
message=MessageEnum.task_add_fail.value[1],
data='')
def post(self):
data = request.get_data('data')
project = json.loads(data.decode('utf-8'))
projec = project['project']
interfatype = project['interfacetype']
if interfatype == 'http':
typeinterface = 'http'
elif interfatype == 'dubbo':
typeinterface = 'dubbo'
else:
typeinterface = 'none'
if not project:
return ({
'msg': MessageEnum.project_not_exict.value[0],
'code': MessageEnum.project_not_exict.value[1],
'data': ''
})
project_is = Project.query.filter_by(project_name=str(projec)).first()
if project_is.status is True:
return reponse(message=MessageEnum.project_delet_free.value[1],
code=MessageEnum.project_delet_free.value[0],
data='')
interfaclist = Interface.query.filter_by(
projects_id=project_is.id, status=False,
interfacetype=interfatype).all()
interfaclists = []
for interface in interfaclist:
interfaclists.append({
'model_id': interface.models.model_name,
'projects_id': interface.projects.project_name,
'id': interface.id,
'Interface_url': interface.Interface_url,
'Interface_meth': interface.Interface_meth,
'Interface_headers': interface.Interface_headers,
'Interface_name': interface.Interface_name
})
data = {}
data['data'] = interfaclists
data['typeinter'] = typeinterface
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0],
data=data)
def put(self):
data = request.get_json()
config_is = GeneralConfiguration.query.filter_by(
id=int(data['id'])).first()
if not config_is:
return reponse(code=MessageEnum.common_is_not_exict.value[0],
message=MessageEnum.common_is_not_exict.value[1],
data='')
if data['type'] == "key-value":
config_is.user = current_user
config_is.style = 0
config_is.key = data["key"]
db.session.commit()
return reponse(code=MessageEnum.common_edit_is_success.value[0],
message=MessageEnum.common_edit_is_success.value[1])
elif data['type'] == 'token':
config_is.user = current_user
config_is.style = 1,
config_is.name = data['name']
config_is.token_method = data['method'],
config_is.token_parame = data['parame'],
config_is.token_url = data['url']
db.session.commit()
return reponse(
code=MessageEnum.successs.value[0],
message=MessageEnum.common_gene_not_support.value[1])
elif data['type'] == 'sql':
testevnet = Interfacehuan.query.filter_by(
id=int(data['eventid'])).first()
if not testevnet:
return reponse(
code=MessageEnum.testeveirment_not_exict.value[0],
message=MessageEnum.testeveirment_not_exict.value[1])
config_is.user = current_user
config_is.style = 1
config_is.name = data['name']
config_is.testevent = testevnet
config_is.sqlurl = data['sql']
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == 'http请求':
config_is.user = current_user
config_is.style = 1
config_is.name = data['name']
config_is.request_method = data['method']
config_is.request_parame = data['parame']
config_is.request_url = data['url']
db.session.commit()
return reponse(
code=MessageEnum.successs.value[0],
message=MessageEnum.common_gene_not_support.value[1])
else:
return reponse(
code=MessageEnum.common_gene_not_support.value[0],
message=MessageEnum.common_gene_not_support.value[1],
data='')
def post(self):
project = request.get_data('value')
project = project.decode('utf-8')
changpr = Project.query.filter_by(project_name=project).first()
if not changpr:
return reponse(code=MessageEnum.project_search.value[0],
message=MessageEnum.project_search.value[1],
data='')
if changpr.status == True:
return reponse(code=MessageEnum.project_delet_free.value[0],
message=MessageEnum.project_delet_free.value[1],
data='')
testevent = Interfacehuan.query.filter_by(projects=changpr,
status=False).all()
testeventlist = []
for testeven in testevent:
testeventlist.append({"url": testeven.url})
return reponse(code=MessageEnum.successs.value[0],
data=testeventlist,
message=MessageEnum.successs.value[1])
def post(self):
data_post = request.get_json()
name_exict = Mockserver.query.filter_by(name=data_post['name']).first()
if name_exict:
return reponse(code=MessageEnum.mock_name_only_one.value[0],
message=MessageEnum.mock_name_only_one.value[1])
if data_post['checkout'] == u'是':
is_check = True
else:
is_check = False
if data_post['checkouheaders'] == u'是':
is_headers = True
else:
is_headers = False
if data_post['kaiqi'] == u'是':
is_kaiqi = True
else:
is_kaiqi = False
new_mock = Mockserver(name=data_post['name'])
new_mock.make_uers = current_user.id
new_mock.path = data_post['path']
new_mock.methods = data_post['meth']
new_mock.headers = data_post['headers']
new_mock.description = data_post['desc']
new_mock.fanhui = data_post['back']
new_mock.params = data_post['parm']
new_mock.rebacktype = data_post['type']
new_mock.status = is_kaiqi
new_mock.ischeck = is_check
new_mock.is_headers = is_headers
new_mock.update_time = datetime.datetime.now()
db.session.add(new_mock)
try:
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
except Exception as e:
logger.error(e)
db.session.rollback()
return reponse(code=MessageEnum.create_mock_error.value[0],
message=MessageEnum.create_mock_error.value[1])
def gettest(): # ajax获取项目的测试用例
projec = (request.get_data('project')).decode('utf-8')
if not projec:
return reponse(code=MessageEnum.successs.value[0],
data={},
message=MessageEnum.successs.value[1])
proje = Project.query.filter_by(project_name=str(projec)).first()
if not proje:
return reponse(code=MessageEnum.successs.value[0],
data={},
message=MessageEnum.successs.value[1])
testyong = InterfaceTest.query.filter_by(projects_id=proje.id).all()
testyong_list = []
for i in testyong:
if i.status == True:
continue
else:
testyong_list.append({'name': i.Interface_name, 'id': i.id})
return reponse(code=MessageEnum.successs.value[0],
data=testyong_list,
message=MessageEnum.successs.value[1])
def post(self):
id = request.get_data('id')
project = id.decode('utf-8')
if not project:
return reponse(message=MessageEnum.request_null_message.value[1],
code=MessageEnum.request_null_message.value[0],
data='')
peoject = Project.query.filter_by(project_name=project,
status=False).first()
if not peoject:
return reponse(message=MessageEnum.project_not_exict.value[1],
code=MessageEnum.project_not_exict.value[0],
data='')
tesatcaelist = InterfaceTest.query.filter_by(projects_id=peoject.id,
status=False).all()
caselit = []
for i in tesatcaelist:
caselit.append(i.id)
return reponse(code=MessageEnum.request_success.value[0],
message=MessageEnum.request_success.value[1],
data=(caselit))
def dispatch_request(self):
if chckuserpermisson() is False:
return reponse(code=MessageEnum.permiss_is_ness.value[0],
message=MessageEnum.permiss_is_ness.value[1],
data='')
userjobnum = request.get_json()
try:
id = int(userjobnum['id'])
job_num = int(userjobnum['jobnum'])
except Exception as e:
logger.exception(e)
return reponse(code=MessageEnum.activ_is_int.value[0],
message=MessageEnum.activ_is_int.value[1])
user = User.query.filter_by(id=id, status=False).first()
if not user:
return reponse(
code=MessageEnum.login_user_not_exict_message.value[0],
message=MessageEnum.login_user_not_exict_message.value[1])
try:
user_job = User.query.filter_by(jobnum=job_num).first()
if user_job:
return reponse(code=MessageEnum.activi_user_jobnum.value[0],
message=MessageEnum.activi_user_jobnum.value[1])
except Exception as e:
logger.exception(e)
pass
if (user.jobnum is None or user.jobnum == "None"):
user.jobnum = job_num
db.session.add(user)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1],
data='')
return reponse(code=MessageEnum.activi_user_jobnum_is.value[0],
message=MessageEnum.activi_user_jobnum_is.value[1])
def put(self):
data = request.data.decode('utf-8')
json_data = json.loads(data)
id = json_data['id']
name = json_data['name']
prohect = Project.query.filter_by(id=id).first()
if not prohect:
new = Project(project_name=name, project_user_id=current_user.id)
db.session.add(new)
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
prohect.project_name = name
try:
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(code=MessageEnum.eidt_excption.value[0],
message=MessageEnum.eidt_excption.value[1])
def post(self):
data = request.get_json()
json_data = data
project = json_data['project']
url = json_data['url']
desc = json_data['desc']
name = json_data['name']
host = json_data['host']
port = json_data['port']
usernmae = json_data['username']
password = json_data['password']
url_old = Interfacehuan.query.filter_by(url=str(url)).first()
if url_old:
return reponse(
message=MessageEnum.testeveirment_use_one_nam.value[1],
code=MessageEnum.testeveirment_use_one_nam.value[0],
data='')
prkcyt = Project.query.filter_by(project_name=project).first()
testevent = Interfacehuan(url=url,
desc=desc,
project=prkcyt.id,
database=name,
databaseuser=usernmae,
databasepassword=password,
dbhost=host,
dbport=port,
make_user=current_user.id)
db.session.add(testevent)
try:
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.error(e)
db.session.rollback()
return reponse(message=MessageEnum.add_case_erro, code=211)
def post(self):
data = request.get_json()
name = data['name']
password = data['password']
work = data['work']
project = data['project']
email = data['email']
use = User.query.filter_by(username=name).first()
if use:
return reponse(message=MessageEnum.user_is_exict.value[1],
code=MessageEnum.user_is_exict.value[0])
emai = User.query.filter_by(user_email=str(email)).first()
if emai:
return reponse(message=MessageEnum.email_only_one.value[1],
code=MessageEnum.email_only_one.value[0])
wrok = Work.query.filter_by(name=work).first()
new_user = User(username=name, user_email=email)
new_user.set_password(password)
new_user.work_id = wrok.id
db.session.add(new_user)
try:
db.session.commit()
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(message=MessageEnum.model_edit_fial.value[1],
code=MessageEnum.model_edit_fial.value[0])
if len(project) <= 0:
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
else:
try:
user_id = User.query.filter_by(username=name).first()
for proj in project:
project_one = Project.query.filter_by(
project_name=proj).first()
quanxian = Quanxian(project=project_one.id, rose=1)
quanxian.user.append(user_id)
db.session.add(quanxian)
db.session.commit()
return reponse(message=MessageEnum.successs.value[1],
code=MessageEnum.successs.value[0])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(message=MessageEnum.model_edit_fial.value[1],
code=MessageEnum.model_edit_fial.value[0])
def dispatch_request(self):
if chckuserpermisson() is False:
return reponse(code=MessageEnum.permiss_is_ness.value[0],
message=MessageEnum.permiss_is_ness.value[1],
data='')
projec = request.get_json()
try:
username = projec['username']
por = projec['url']
if por == '':
return reponse(code=MessageEnum.select_project_not.value[0],
message=MessageEnum.select_project_not.value[1],
data='')
pan_user = User.query.filter_by(username=username).first()
if not pan_user:
return reponse(
code=MessageEnum.login_user_not_exict_message.value[0],
message=MessageEnum.login_user_not_exict_message.value[1],
data='')
if pan_user.is_sper is True:
return reponse(
code=MessageEnum.super_admin_not_set_project.value[0],
message=MessageEnum.super_admin_not_set_project.value[1],
data='')
pand_por = Project.query.filter_by(project_name=por).first()
if not pand_por:
return reponse(
code=MessageEnum.set_project_bot_exict.value[0],
message=MessageEnum.set_project_bot_exict.value[1],
data='')
pro_per = Quanxian.query.filter_by(project=pand_por.id).all()
oneadmin = []
for i in pro_per:
if i.rose == 2:
oneadmin.append(i.user.all())
if [pan_user] in oneadmin:
return reponse(code=MessageEnum.set_is_admin.value[0],
message=MessageEnum.set_is_admin.value[1])
if (len(oneadmin)) > OneAdminCount:
return reponse(code=MessageEnum.project_admin_many.value[0],
message=MessageEnum.project_admin_many.value[1])
for roses in pan_user.quanxians:
if roses.project == pand_por.id:
roses.rose = 2
try:
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
except Exception as e:
logger.exception(e)
db.session.rollback()
return reponse(code=MessageEnum.set_fail.value[0],
message=MessageEnum.set_fail.value[1],
data='')
except Exception as e:
logger.exception(e)
return reponse(
code=MessageEnum.set_project_admin_exception.value[0],
message=MessageEnum.set_project_admin_exception.value[1] +
'原因是：%s' % e,
data='')
def post(self):
data = request.get_json()
name_is = Action.query.filter_by(name=data['name']).first()
if name_is:
return reponse(code=MessageEnum.re_is_same.value[0],
message=MessageEnum.re_is_same.value[1])
action = Action(name=data['name'], user=current_user)
if data['catepy'] == '前置':
action.category = 0
else:
action.category = 1
if data['type'] == "0":
action.sleepnum = int(data['num'])
action.style = 0
db.session.add(action)
db.session.commit()
return reponse(code=MessageEnum.request_success.value[0],
message=MessageEnum.request_success.value[1])
elif data['type'] == "1":
testevnet = Interfacehuan.query.filter_by(
id=int(data['eventid'])).first()
if not testevnet:
return reponse(
code=MessageEnum.testeveirment_not_exict.value[0],
message=MessageEnum.testeveirment_not_exict.value[1])
action.testevent = testevnet
action.style = 1
action.sql = data['sql']
db.session.add(action)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == "2":
action.style = 2
testevnet = Interfacehuan.query.filter_by(
id=int(data['eventid'])).first()
if not testevnet:
return reponse(
code=MessageEnum.testeveirment_not_exict.value[0],
message=MessageEnum.testeveirment_not_exict.value[1])
case_is = InterfaceTest.query.filter_by(
id=int(data['caseid'])).first()
if not case_is:
return reponse(code=MessageEnum.case_not_exict.value[0],
message=MessageEnum.case_not_exict.value[1])
action.testevent = testevnet
action.caseid = int(data['caseid'])
db.session.add(action)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == "3":
action.style = 3
action.requestsurl = data['url']
action.requestmethod = data['method']
action.requestsparame = data['parame']
db.session.add(action)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
else:
return reponse(code=MessageEnum.re_is_not_exitc.value[0],
message=MessageEnum.re_is_not_exitc.value[1],
data='')
def post(self):
try:
data = request.get_json()
config = GeneralConfiguration.query.filter_by(
name=data['name']).first()
if config:
return reponse(code=MessageEnum.common_is_same.value[0],
message=MessageEnum.common_is_same.value[1],
data='')
if data['type'] == "key-value":
newconfig = GeneralConfiguration(user=current_user,
style=0,
key=data["key"],
name=data['name'])
db.session.add(newconfig)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == 'token':
newconfig = GeneralConfiguration(user=current_user,
style=1,
name=data['name'],
token_method=data['method'],
token_parame=data['parame'],
token_url=data['url'])
db.session.add(newconfig)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == 'sql':
testevnet = Interfacehuan.query.filter_by(
id=int(data['eventid'])).first()
if not testevnet:
return reponse(
code=MessageEnum.testeveirment_not_exict.value[0],
message=MessageEnum.testeveirment_not_exict.value[1])
newconfig = GeneralConfiguration(user=current_user,
style=1,
name=data['name'],
testevent=testevnet,
sqlurl=data['sql'])
db.session.add(newconfig)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
elif data['type'] == 'http请求':
newconfig = GeneralConfiguration(user=current_user,
style=1,
name=data['name'],
request_method=data['method'],
request_parame=data['parame'],
request_url=data['url'])
db.session.add(newconfig)
db.session.commit()
return reponse(code=MessageEnum.successs.value[0],
message=MessageEnum.successs.value[1])
else:
return reponse(
code=MessageEnum.common_gene_not_support.value[0],
message=MessageEnum.common_gene_not_support.value[1],
data='')
except Exception as e:
logger.exception(e)
return reponse(code=MessageEnum.parames_not_null.value[0],
data=MessageEnum.parames_not_null.value[1])
