def login_operation(request):
# Post中的参数会对应到Form中进行验证
login_form = LoginForm(request.POST)
# is_valid返回验证结果
if login_form.is_valid():
username = request.POST.get('account')
password = request.POST.get('password')
# 登录成功返回User对象，登录失败返回None
user = authenticate(username=username, password=password)
if user is not None:
# 使用Django验证系统登录，生成session，并且保存在数据库和浏览器
login(request, user)
# 设置session过期时间
request.session.set_expiry(SECONDS_OF_ONE_HOUR * 24)
# 清除所有已经失效的session
request.session.clear_expired()
result = get_ajax_msg(SUC_CODE, RESULT_SUC_TAG, "登录成功")
else:
result = get_ajax_msg(FAIL_CODE, RESULT_FAIL_TAG, "用户名或密码错误")
else:
# TODO 是否可以只从校验拿到错误信息
pattern = '(?<=<li>)\S+(?=</li>)'
items = list(login_form.errors.items())[0]
content = str(items[1])
msg = re.search(pattern, content).group()
result = get_ajax_msg(INVALID_INPUT_CODE, RESULT_FAIL_TAG, msg)
return result
def project_create(request):
if request.method == 'GET':
return render(request, 'api/project_new.html')
elif request.method == 'POST':
if request.user.has_perm(AUTH_ADD_PROJECT):
params = json.loads(request.body.decode('utf-8'))
model_form = ProjectModelForm(params)
if model_form.is_valid():
project_name = params['project_name']
if not ProjectInfo.objects.filter(
project_name=project_name).exists():
# 没有相同名字的项目
model_form.save()
project = ProjectInfo.objects.filter(
project_name=project_name)
# DebugTalk(belong_project=project.first()).save()
# 读取默认文件内容，存入默认提供的方法
content = get_default_debugtalk()
DebugTalk.objects.create(belong_project=project.first(),
debugtalk=content)
# 项目创建者默认拥有该项目的查询，修改权限
assign_perm(AUTH_VIEW, request.user, project)
assign_perm(AUTH_UPDATE, request.user, project)
return JsonResponse(get_ajax_msg(1, 1, '新增工程成功！'))
else:
# 存在相同名字的项目
return JsonResponse(get_ajax_msg(0, 0, '已存在此项目！'))
else:
msg = get_validate_form_msg(model_form)
return JsonResponse(get_ajax_msg(0, 0, msg))
else:
return JsonResponse(get_ajax_msg(0, 0, '用户没有创建项目的权限'))
def project_search(request):
if request.method == "POST":
project_name = request.POST.get('project_name')
person_name = request.POST.get('person_name')
index = int(request.POST.get('index'))
if len(project_name) == 0 and len(person_name) == 0:
return JsonResponse(get_ajax_msg(0, 0, '搜索条件无效'))
else:
projects = ProjectInfo.objects.all()
if len(project_name) > 0:
projects = projects.filter(project_name__contains=project_name)
if len(person_name) > 0:
projects = projects.filter(
responsible_name__contains=person_name)
if projects is None:
return JsonResponse(get_ajax_msg(0, 0, '查询出错'))
objects = get_objects_for_user(request.user, AUTH_VIEW,
projects) # 根据用户权限筛选项目对象
projects = pagination_for_objects(objects, index)
count = objects.count()
data = dataToJson([model_to_dict(i) for i in projects])
return JsonResponse(
get_ajax_msg(1, 1, '搜索成功', {
'projects': data,
'count': count,
'currPage': index
}))
def assign_auth(request):
if request.user.is_superuser:
if request.method == 'POST':
user_id = request.POST.get('userId')
if user_id != DEFAULT_USER_ID:
try:
user = UserInfo.objects.get(id=user_id)
except ObjectDoesNotExist:
return JsonResponse(get_ajax_msg(0, 0, '没有该名用户'))
else:
projects = ProjectInfo.objects.filter().order_by('-id')
empty_user_auth(user, projects, add_perm_list) # 清空用户权限
is_superuser = request.POST.get('is_superuser')
checks = request.POST.get('checks')
auths = request.POST.get('auths')
# 分配用户是否为管理员
user.is_superuser = is_superuser
user.save()
# 分配创建项目，模块，用例，任务权限
if checks:
for perm in checks.split(','):
assign_perm(perm, user)
# 分配项目的查询，修改，删除权限
if auths:
auths = request.POST.get('auths').split(',')
for auth in auths:
project_id = auth.split('-')[0]
auth_name = auth.split('-')[1]
project = ProjectInfo.objects.get(id=project_id)
assign_perm(auth_name, user, project)
return JsonResponse(get_ajax_msg(1, 1, '分配权限成功'))
else:
return JsonResponse(get_ajax_msg(0, 0, '请选择用户'))
else:
return JsonResponse(get_ajax_msg(0, 0, '该名用户没有管理员权限'))
def project_update(request):
if request.method == 'POST':
model_form = ProjectModelForm(request.POST)
if model_form.is_valid():
project_id = request.POST.get('id')
project_name = request.POST.get('project_name')
responsible_name = request.POST.get('responsible_name')
test_user = request.POST.get('test_user')
dev_user = request.POST.get('dev_user')
publish_app = request.POST.get('publish_app')
simple_desc = request.POST.get('simple_desc')
other_desc = request.POST.get('other_desc')
# 检查用户是否拥有修改权限
if not request.user.has_perm(
AUTH_UPDATE, ProjectInfo.objects.get(id=project_id)):
return JsonResponse(get_ajax_msg(0, 0, '用户没有修改该项目的权限'))
if ProjectInfo.objects.update_project(
project_id,
project_name=project_name,
responsible_name=responsible_name,
test_user=test_user,
dev_user=dev_user,
publish_app=publish_app,
simple_desc=simple_desc,
other_desc=other_desc):
return JsonResponse(get_ajax_msg(1, 1, '修改项目成功', {}))
else:
return JsonResponse(get_ajax_msg(0, 0, '修改项目失败', {}))
else:
msg = get_validate_form_msg(model_form)
return JsonResponse(get_ajax_msg(0, 1, msg))
def module_update(request):
if request.method == 'POST':
model_form = ModuleModelForm(request.POST)
if model_form.is_valid():
module_id = request.POST.get('id')
module_name = request.POST.get('module_name')
project_name = request.POST.get('project_name')
test_user = request.POST.get('test_user')
simple_desc = request.POST.get('simple_desc')
other_desc = request.POST.get('other_desc')
if check_perm(request.user, ModuleInfo.objects.get(id=module_id),
AUTH_UPDATE):
if ModuleInfo.objects.update_module(module_id,
module_name=module_name,
project_name=project_name,
test_user=test_user,
simple_desc=simple_desc,
other_desc=other_desc):
return JsonResponse(get_ajax_msg(1, 1, '修改模块成功', {}))
else:
return JsonResponse(get_ajax_msg(0, 0, '修改模块失败', {}))
else:
return JsonResponse(get_ajax_msg(0, 0, '用户没有修改该模块的权限'))
else:
msg = get_validate_form_msg(model_form)
return JsonResponse(get_ajax_msg(0, 0, msg))
def module_create(request):
if request.method == 'GET':
return render(request, 'api/module_new.html')
elif request.method == 'POST':
if request.user.has_perm(AUTH_ADD_MODULE):
if request.method == 'POST':
model_form = ModuleModelForm(request.POST)
if model_form.is_valid():
project_id = request.POST.get('belong_project')
if not ProjectInfo.objects.filter(id=project_id).exists():
return JsonResponse(get_ajax_msg(0, 0, '此项目不存在', {}))
else:
if ModuleInfo.objects.filter(
module_name=model_form.instance.module_name
).filter(belong_project_id=project_id).exists():
return JsonResponse(
get_ajax_msg(0, 0, '此模块已存在', {}))
model_form.instance.belong_project_id = project_id
model_form.save()
return JsonResponse(get_ajax_msg(1, 1, '添加模块成功', {}))
else:
msg = get_validate_form_msg(model_form)
return JsonResponse(get_ajax_msg(0, 0, msg))
else:
return JsonResponse(get_ajax_msg(0, 0, '用户没有创建模块的权限'))
def case_query(request):
if request.method == "POST":
case_id = request.POST.get('id')
cases = TestCaseInfo.objects.filter(id=case_id)
moduleid_to_projectid = {}
moduleid_to_modulename = {}
if len(cases) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
if cases is not None and len(cases) > 0:
for case in cases:
# 所属模块id对应模块名称
module_id = case.belong_module_id
module_name = case.belong_module.module_name
moduleid_to_modulename[str(module_id)] = module_name
# 所属模块id对应项目id
project_id = case.belong_module.belong_project_id
moduleid_to_projectid[str(module_id)] = project_id
cases = filter_cases_for_user(request.user, cases, AUTH_VIEW)
data = dataToJson([model_to_dict(i) for i in cases])
data = json.loads(data)
return JsonResponse(
get_ajax_msg(
1, 1, '获取用例信息成功', {
'cases': data,
'proInfo': moduleid_to_projectid,
'moduleInfo': moduleid_to_modulename
}))
def task_run(request):
global is_timer_start
global run_task_list
global run_job_dict
if request.method == 'POST':
task_id = request.POST.get('id')
tasks = TaskInfo.objects.filter(id=task_id)
if len(tasks) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
task = tasks[0]
if not task.is_run:
if task.start_time > datetime.datetime.now(): # 任务开始时间必须大于当前时间
pass
else:
task.start_time = datetime.datetime.now() + datetime.timedelta(
seconds=10)
# if not is_timer_start:
# is_timer_start = True
# start_task_timer = StartTaskTimer(run_task_list, run_job_dict)
# start_task_timer.start()
run_task_list.append(task)
task.is_run = True
task.save()
connection.close()
return JsonResponse(get_ajax_msg(1, 1, '该任务成功运行'))
else:
connection.close()
return JsonResponse(get_ajax_msg(0, 0, '该任务正在运行'))
def task_stop(request):
global run_task_list
global run_job_dict
if request.method == 'POST':
task_id = request.POST.get('id')
tasks = TaskInfo.objects.filter(id=task_id)
if len(tasks) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
task = tasks[0]
if task.is_run:
task.is_run = False
task.fail_times = 0
task.save()
# if task in run_task_list:
# run_task_list.remove(task) # 从运行任务列表中删除该任务
try:
# jobs = run_job_dict[task.id]
# for job in jobs:
schedule.cancel_job(task.id)
except KeyError:
print('非循环任务')
return JsonResponse(get_ajax_msg(1, 1, '该任务成功停止'))
else:
return JsonResponse(get_ajax_msg(0, 0, '该任务没有运行'))
def logout_operation(request):
logout(request)
if not request.user.is_authenticated:
result = get_ajax_msg(SUC_CODE, RESULT_SUC_TAG, "注销成功")
else:
result = get_ajax_msg(FAIL_CODE, RESULT_FAIL_TAG, "注销失败")
return result
def task_create(request):
if request.method == 'GET':
return render(request, 'api/task_new.html')
elif request.user.has_perm(AUTH_ADD_TASK):
if request.method == 'POST':
model_form = TaskModelForm(request.POST)
if model_form.is_valid():
task_name = request.POST.get('task_name')
env_id = request.POST.get('belong_env')
project_id = request.POST.get('belong_project')
module_id = request.POST.get('belong_module')
emails = request.POST.get('receiver_email')
start_time = datetime.datetime.fromtimestamp(
int(request.POST.get('start_time')) / 1000)
if request.POST.get('is_loop') == 'true':
is_loop = True
elif request.POST.get('is_loop') == 'false':
is_loop = False
interval_minute = request.POST.get('interval_minute')
error_msg = None
if not EnvInfo.objects.filter(id=env_id).exists():
error_msg = '此环境不存在'
elif not ProjectInfo.objects.filter(id=project_id).exists():
error_msg = '此项目不存在'
elif not ModuleInfo.objects.filter(id=module_id).exists():
error_msg = '此模块不存在'
elif TaskInfo.objects.filter(
task_name=task_name,
belong_module_id=module_id).exists():
error_msg = '已存在此任务'
elif start_time <= datetime.datetime.now():
error_msg = '任务开始时间早于当前时间'
elif is_loop and int(interval_minute) < 1:
error_msg = '任务开始循环间隔时间不能小于1分钟'
elif not validate_emails(emails.split(';')):
error_msg = '邮箱格式错误'
if error_msg is not None:
return JsonResponse(get_ajax_msg(0, 0, error_msg, {}))
model_form.instance.belong_env_id = env_id
model_form.instance.belong_project_id = project_id
model_form.instance.belong_module_id = module_id
model_form.instance.start_time = start_time
model_form.instance.receiver_email = deal_emails(
emails.split(';'))
model_form.save()
for case_id in request.POST.get('case_list').split(','):
task = TaskInfo.objects.get(
task_name=request.POST.get('task_name'))
case = TestCaseInfo.objects.get(id=case_id)
task.cases.add(case)
return JsonResponse(get_ajax_msg(1, 1, '添加任务成功', {}))
else:
msg = get_validate_form_msg(model_form)
return JsonResponse(get_ajax_msg(0, 0, msg))
else:
return JsonResponse(get_ajax_msg(0, 0, '用户没有创建任务的权限'))
def env_query(request):
if request.method == "POST":
env_info = json.loads(request.body.decode('utf-8'))
env_id = env_info['id']
envs = EnvInfo.objects.filter(id=env_id)
if len(envs) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
data = dataToJson([model_to_dict(i) for i in envs])
return JsonResponse(get_ajax_msg(1, 1, '获取环境信息成功', {'envs': data}))
def module_query(request):
if request.method == 'POST':
module_id = request.POST.get('id')
modules = ModuleInfo.objects.filter(id=module_id)
if len(modules) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
modules = filter_modules_for_user(request.user, modules, AUTH_VIEW)
data = dataToJson([model_to_dict(i) for i in modules])
return JsonResponse(get_ajax_msg(1, 1, '获取模块成功', {'modules': data}))
def auth(request):
if request.user.is_superuser:
if request.method == 'GET':
return render(request, 'api/auth.html')
elif request.method == 'POST':
# 初始化权限树
user_id = request.POST.get('userId')
projects = ProjectInfo.objects.filter().order_by('-id')
perm_dict = {
AUTH_VIEW: '查询',
AUTH_UPDATE: '修改',
AUTH_DELETE: '删除'
} # 需要初始化的权限
is_superuser = False
has_add_perm_list = [] # 用户拥有的创建权限列表
auth_list = []
if user_id != DEFAULT_USER_ID:
try:
user = UserInfo.objects.get(id=user_id)
checker = ObjectPermissionChecker(user)
is_superuser = user.is_superuser
has_add_perm_list = check_add_perm_for_user(
user, add_perm_list) # 初始化创建权限部分
except ObjectDoesNotExist:
return JsonResponse(get_ajax_msg(0, 0, '没有该名用户'))
# 初始化项目权限部分
for project in projects:
flag_all = True # 全选项目权限标志
auth_dict = {}
auth_dict['name'] = project.project_name
auth_dict['value'] = project.id
auth_dict['list'] = []
for key, value in perm_dict.items():
perm_name = value
perm_value = str(project.id) + '-' + key
if user_id != DEFAULT_USER_ID:
is_auth = checker.has_perm(key, project)
else:
is_auth = False
flag_all = flag_all and is_auth # 与运算，判断是否全选权限
auth_dict['list'].append({
'name': perm_name,
'value': perm_value,
'checked': is_auth
})
auth_dict['checked'] = flag_all
auth_list.append(auth_dict)
return JsonResponse(
get_ajax_msg(
1, 1, '获取权限列表成功', {
'is_superuser': is_superuser,
'checks': ','.join(has_add_perm_list),
'trees': auth_list
}))
else:
return JsonResponse(get_ajax_msg(0, 0, '该名用户没有管理员权限'))
def case_upload(request):
if request.method == 'POST':
upload_file = request.FILES.get('file', None)
if not upload_file:
return JsonResponse(get_ajax_msg(0, 0, '上传失败！', {}))
result = parse_upload_case(upload_file)
if result:
return JsonResponse(get_ajax_msg(1, 1, '上传成功！', {'case': result}))
else:
return JsonResponse(get_ajax_msg(0, 0, '解析文件失败！', {}))
def project_query(request):
if request.method == 'POST':
project_id = request.POST.get('id')
projects = ProjectInfo.objects.filter(id=project_id)
if len(projects) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
projects = get_objects_for_user(request.user, AUTH_VIEW,
projects) # 根据用户权限筛选项目对象
data = dataToJson([model_to_dict(i) for i in projects])
return JsonResponse(get_ajax_msg(1, 1, '获取项目成功', {'projects': data}))
def task_delete(request):
if request.method == 'POST':
task_id = request.POST.get('id')
tasks = TaskInfo.objects.filter(id=task_id)
if len(tasks) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
if check_perm(request.user, tasks[0], AUTH_DELETE):
tasks[0].delete()
return JsonResponse(get_ajax_msg(1, 1, '删除成功', {}))
else:
return JsonResponse(get_ajax_msg(0, 0, '用户没有删除该任务的权限'))
def env_delete(request):
if request.method == "POST":
env_info = json.loads(request.body.decode('utf-8'))
env_id = env_info['id']
env = EnvInfo.objects.filter(id=env_id)
if len(env) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
if EnvInfo.objects.delete_env(env_id):
return JsonResponse(get_ajax_msg(1, 1, '删除成功', {}))
else:
return JsonResponse(get_ajax_msg(0, 0, '删除失败', {}))
def captcha_operation(request):
receiver = request.POST.get('receiver')
send_type = request.POST.get('send_type')
if receiver != '' and send_type != '':
result_code = send_captcha(receiver, send_type)
if result_code == 1:
result = get_ajax_msg(SUC_CODE, RESULT_SUC_TAG, "发送成功")
else:
result = get_ajax_msg(FAIL_CODE, RESULT_FAIL_TAG, "发送失败")
else:
result = get_ajax_msg(INVALID_INPUT_CODE, RESULT_FAIL_TAG, "邮箱不能为空")
return result
def module_search(request):
if request.method == 'POST':
# 当要搜索某个项目下的模块时，可通过传入项目id进行获取
project_id = request.POST.get('project_id')
if project_id != None:
modules = ModuleInfo.objects.all().filter(
belong_project_id=project_id)
count = modules.count()
data = dataToJson([model_to_dict(i) for i in modules])
return JsonResponse(
get_ajax_msg(1, 1, '搜索成功', {
'modules': data,
'count': count
}))
index = int(request.POST.get('index'))
project_name = request.POST.get('project_name')
module_name = request.POST.get('module_name')
test_person = request.POST.get('test_person')
project_name_dic = {}
if len(project_name) == 0 and len(module_name) == 0 and len(
test_person) == 0:
return JsonResponse(get_ajax_msg(0, 0, '搜索条件无效'))
else:
modules = ModuleInfo.objects.all()
if len(project_name) != 0 and project_name != '项目名称':
modules = modules.filter(
belong_project__project_name__contains=project_name)
if len(module_name) != 0:
modules = modules.filter(module_name__contains=module_name)
if len(test_person) != 0:
modules = modules.filter(test_user__contains=test_person)
if modules is None:
return JsonResponse(get_ajax_msg(0, 0, '查询出错'))
if modules is not None and len(modules) > 0:
modules = filter_modules_for_user(request.user,
modules.order_by('-id'),
AUTH_VIEW) # 根据用户权限筛选模块
for module in modules:
proID = module.belong_project_id
proName = module.belong_project.project_name
project_name_dic[str(proID)] = proName
count = len(modules)
modules = pagination_for_objects(modules, index)
data = dataToJson([model_to_dict(i) for i in modules])
return JsonResponse(
get_ajax_msg(
1, 1, '搜索成功', {
'modules': data,
'count': count,
'currPage': index,
'proInfo': project_name_dic
}))
def case_delete(request):
if request.method == "POST":
case_id = request.POST.get('id')
cases = TestCaseInfo.objects.filter(id=case_id)
if len(cases) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
# 检查用户是否拥有删除权限
if check_perm(request.user, cases[0], AUTH_DELETE):
cases[0].delete()
return JsonResponse(get_ajax_msg(1, 1, '删除成功'))
else:
return JsonResponse(get_ajax_msg(0, 0, '用户没有删除该模块的权限'))
def task_query(request):
if request.method == 'POST':
task_id = request.POST.get('id')
tasks = TaskInfo.objects.filter(id=task_id)
if len(tasks) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
tasks = filter_tasks_for_user(request.user, tasks, AUTH_VIEW)
task_info_list = []
for task in tasks:
task_dict = task2Dict(task)
task_info_list.append(task_dict)
data = dataToJson(task_info_list)
return JsonResponse(get_ajax_msg(1, 1, '获取任务成功', {'tasks': data}))
def project_delete(request):
if request.method == 'POST':
project_id = request.POST.get('id')
projects = ProjectInfo.objects.filter(id=project_id)
if len(projects) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
# 检查用户是否拥有删除权限
if not request.user.has_perm(AUTH_DELETE, projects[0]):
return JsonResponse(get_ajax_msg(0, 0, '用户没有删除该项目的权限'))
if ProjectInfo.objects.delete_project(project_id):
return JsonResponse(get_ajax_msg(1, 1, '删除成功', {}))
else:
return JsonResponse(get_ajax_msg(0, 0, '删除失败', {}))
def task_search(request):
if request.method == 'POST':
index = int(request.POST.get('index'))
task_name = request.POST.get('task_name')
project_name = request.POST.get('project_name')
module_name = request.POST.get('module_name')
tasks = None
env_name_dic = {}
project_name_dic = {}
module_name_dic = {}
count = 0
if len(task_name) == 0 and len(project_name) == 0 and len(
module_name) == 0:
return JsonResponse(get_ajax_msg(0, 0, '搜索条件无效'))
else:
tasks = TaskInfo.objects.all()
if len(module_name) != 0 and module_name != '模块名称':
tasks = tasks.filter(
belong_module__module_name__contains=module_name)
if len(project_name) != 0 and project_name != '项目名称':
tasks = tasks.filter(
belong_project__project_name__contains=project_name)
if len(task_name) != 0:
tasks = tasks.filter(task_name__contains=task_name)
if tasks == None:
return JsonResponse(get_ajax_msg(0, 0, '查询出错'))
if tasks != None and len(tasks) > 0:
tasks = filter_tasks_for_user(request.user, tasks.order_by('-id'),
AUTH_VIEW) # 根据用户权限筛选模块
for task in tasks:
append_env_dict(task, env_name_dic)
append_project_dict(task, project_name_dic)
append_module_dict(task, module_name_dic)
count = len(tasks)
tasks = pagination_for_objects(tasks, index)
task_info_list = []
for task in tasks:
task_dict = task2Dict(task)
task_info_list.append(task_dict)
data = dataToJson(task_info_list)
return JsonResponse(
get_ajax_msg(
1, 1, '搜索成功', {
'tasks': data,
'count': count,
'currPage': index,
'envInfo': env_name_dic,
'proInfo': project_name_dic,
'moduleInfo': module_name_dic
}))
def module_delete(request):
if request.method == 'POST':
module_id = request.POST.get('id')
modules = ModuleInfo.objects.filter(id=module_id)
if len(modules) == 0:
return JsonResponse(get_ajax_msg(0, 0, '没有这条数据', {}))
# 检查用户是否拥有删除权限
if check_perm(request.user, modules[0], AUTH_DELETE):
if ModuleInfo.objects.delete_module(module_id):
return JsonResponse(get_ajax_msg(1, 1, '删除成功'))
else:
return JsonResponse(get_ajax_msg(0, 0, '删除失败'))
else:
return JsonResponse(get_ajax_msg(0, 0, '用户没有删除该模块的权限'))
def module_list(request):
if request.method == 'GET':
return render(request, 'api/module_list.html')
elif request.method == 'POST':
index = int(request.POST.get('index'))
project_name_dic = {}
# 根据用户权限筛选模块
objects = filter_modules_for_user(request.user,
ModuleInfo.objects.order_by('-id'),
AUTH_VIEW)
modules = pagination_for_objects(objects, index)
if modules is not None and len(modules) > 0:
for module in modules:
project_id = module.belong_project_id
project_name = module.belong_project.project_name
project_name_dic[str(project_id)] = project_name
count = len(objects)
data = dataToJson([model_to_dict(i) for i in modules])
return JsonResponse(
get_ajax_msg(
1, 1, '获取模块列表成功', {
'modules': data,
'count': count,
'currPage': index,
'proInfo': project_name_dic
}))
def task_list(request):
if request.method == "GET":
return render(request, 'api/task_list.html')
elif request.method == "POST":
index = int(request.POST.get('index'))
env_name_dic = {}
project_name_dic = {}
module_name_dic = {}
results = filter_tasks_for_user(
request.user,
TaskInfo.objects.filter().order_by('-id'), AUTH_VIEW)
tasks = pagination_for_objects(results, index)
if tasks is not None and len(tasks) > 0:
for task in tasks:
append_env_dict(task, env_name_dic)
append_project_dict(task, project_name_dic)
append_module_dict(task, module_name_dic)
count = len(results)
task_info_list = []
for task in tasks:
task_dict = task2Dict(task)
task_info_list.append(task_dict)
data = dataToJson(task_info_list)
return JsonResponse(
get_ajax_msg(
1, 1, '获取任务列表成功', {
'tasks': data,
'count': count,
'currPage': index,
'envInfo': env_name_dic,
'proInfo': project_name_dic,
'moduleInfo': module_name_dic
}))
def case_search_with_id(request):
if request.method == 'POST':
project_id = request.POST.get('project_id', 0)
module_id = request.POST.get('module_id', 0)
case_id = request.POST.get('case_id', 0)
cases = None
project_name_dic = {}
module_name_dic = {}
count = 0
if case_id != 0:
cases = TestCaseInfo.objects.filter(id=case_id)
elif module_id != 0:
cases = TestCaseInfo.objects.filter(belong_module_id=module_id)
elif project_id != 0:
cases = TestCaseInfo.objects.filter(
belong_module__belong_project__id=project_id)
if cases is None:
return JsonResponse(get_ajax_msg(0, 0, '查询出错'))
cases = filter_cases_for_user(request.user, cases.order_by('-id'),
AUTH_VIEW)
if cases != None and len(cases) > 0:
for case in cases:
# 所属模块id对应模块名称
module_id = case.belong_module_id
module_name = case.belong_module.module_name
module_name_dic[str(module_id)] = module_name
# 所属模块id对应项目名称
project_name = case.belong_module.belong_project.project_name
project_name_dic[str(module_id)] = project_name
count = len(cases)
tempData = [model_to_dict(i) for i in cases]
del_fields(tempData, [
'variables', 'parameters', 'hooks', 'url', 'request_data',
'headers', 'extract', 'validate', 'include'
])
data = dataToJson(tempData)
return JsonResponse(
get_ajax_msg(
1, 1, '搜索成功', {
'cases': data,
'count': count,
'proInfo': project_name_dic,
'moduleInfo': module_name_dic
}))
elif request.method == 'GET':
pass
def case_run(request):
if request.method == 'POST':
user_name = request.user.username
case_info = json.loads(request.body.decode('utf-8')).pop('case_info')
case_id = case_info.get('case_id')
base_url = case_info.get('base_url', None)
result = case_utils.run_case_by_id(base_url, case_id, None, user_name)
if result == case_utils.RUN_CASE_ERR:
return JsonResponse(get_ajax_msg(0, 0, '用例错误', {}))
elif result == case_utils.RUN_CASE_EXCEPTION:
return JsonResponse(get_ajax_msg(0, 0, '用例解析异常', {}))
else:
return JsonResponse(
get_ajax_msg(1, 1, '已添加到队列', {'report_id': result}))
else:
return JsonResponse(get_ajax_msg(1001, 0, '不支持的请求方式', {}))
