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)