def check_user(user_id): api_logger.debug("准备查询缓存账户数据") # 尝试从mysql中查询 try: api_logger.debug("准备查询账户数据") uinfo_mysql = model_mysql_userinfo.query.filter_by( userId=user_id).first() api_logger.debug("账户数据查询成功") except Exception as e: api_logger.error("账户数据查询失败,失败原因:" + repr(e)) return False else: # 如果mysql中未查询到 if uinfo_mysql is None: return False # 如果mysql中查询到了 else: # 判断账户状态 if uinfo_mysql.userStatus == 0: return False elif uinfo_mysql.userStatus == -1: return False elif uinfo_mysql.userStatus != 1: return False return True
def key_case_delete(): # 初始化返回内容 response_json = {"code": 200, "msg": "数据删除成功", "data": None} # 取出必传入参 request_user_id = flask.request.headers['UserId'] case_id = flask.request.args['id'] # 查用例是否存在,构造基础信息 try: mysql_case_info = model_mysql_case.query.filter( model_mysql_case.id == case_id, model_mysql_case.type == 2).first() except Exception as e: api_logger.error("测试计划类型读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_case_info is None: return route.error_msgs[201]['msg_no_case'] else: indexchang(mysql_case_info.index, mysql_case_info.columnId) mysql_case_info.status = -1 mysql_case_info.updateUserId = request_user_id mysql_case_info.index = 0 mysqlpool.session.commit() # 添加日志 case_logs = model_mysql_caseEditLog(caseId=mysql_case_info.id, type=7) mysqlpool.session.add(case_logs) mysqlpool.session.commit() return response_json
def create_snap_when_close(plan_id): redis_get_table_bytes = modle_redis_apitestplanworktable.query_table( plan_id) if redis_get_table_bytes is not None: # mysql中新增snap # 将status为1的snap全部置为失效 try: model_mysql_tablesnap.query.filter( and_(model_mysql_tablesnap.planId == plan_id, model_mysql_tablesnap.status == 1)).update({"status": 0}) mysqlpool.session.commit() except Exception as e: api_logger.error("model_mysql_tablesnap数据更新失败,失败原因:" + repr(e)) return False else: api_logger.debug("model_mysql_tablesnap数据更新成功") try: mysqlpool.session.add( model_mysql_tablesnap( status=1, planId=plan_id, snapAddTime=datetime.datetime.now(), table=redis_get_table_bytes.decode('utf-8'))) mysqlpool.session.commit() except Exception as e: api_logger.error("mysql_snaps数据写入失败,失败原因:" + repr(e)) else: api_logger.debug("mysql_snaps数据写入成功") finally: # 不管如何,清空redis中的数据 delete_flag = modle_redis_apitestplanworktable.delete(plan_id) api_logger.debug( "redis中缓存清除完毕") if delete_flag else api_logger.debug( "redis中缓存清除失败")
def conflictDtail(conflict_id): response_conflict = {"detail": []} # 判断项目冲突是否存在 try: mysql_conflict_info = model_mysql_projectArchivePendingCase.query.filter( model_mysql_projectArchivePendingCase.id == conflict_id, model_mysql_projectArchivePendingCase.status == 1).first() except Exception as e: api_logger.error("读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_conflict_info is None: return response_conflict # 构造冲突结果返回信息 originalCase = [] projectIdCase = [] otherCase = [] originalCase.append(createcase(mysql_conflict_info.originalCaseId)) projectIdCase.append(createcase(mysql_conflict_info.projectIdCaseId)) otherCase.append(createcase(mysql_conflict_info.otherCaseId)) response_conflict["detail"].append({ "id": mysql_conflict_info.id, "projectId": mysql_conflict_info.projectId, "originalCase": originalCase, "projectIdCase": projectIdCase, "otherCase": otherCase, "status": mysql_conflict_info.status }) return response_conflict
def precondition(caseid, case_precondition): # 更新分多种场景 try: case_Precondition = model_mysql_casePrecondition.query.filter( model_mysql_casePrecondition.caseId == caseid ).first() except Exception as e: api_logger.error("测试计划类型读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: # 原来为空,现在也为空不更新,现在非空则插入数据 if case_Precondition is None: if len(case_precondition) == 0: pass else: new_casePrecondition_info = model_mysql_casePrecondition( content=case_precondition, caseId=caseid ) mysqlpool.session.add(new_casePrecondition_info) mysqlpool.session.commit() else: # 原来不为空,现在为空/非空直接更新即可 case_Precondition.content = case_precondition mysqlpool.session.commit()
def wrapper(*args, **kwargs): request_url = flask.request.url api_logger.debug("URL:" + request_url + ".准备检查请求格式") try: request_parameters = flask.request.json except Exception as e: api_logger.error("URL:" + request_url + "格式检查失败,原因:" + repr(e)) return error_msgs[301]['msg_request_body_not_json'] else: if not request_parameters: return error_msgs[301]['msg_request_body_not_json'] # 检查必传项目 for key in keys: # 如果缺少必传项 if key[0] not in request_parameters: return error_msgs[302]['msg_request_params_incomplete'] else: value = request_parameters[key[0]] # 先检查类型 if type(value) is not key[1]: return error_msgs[301]['msg_value_type_error'] # 如果非布尔型,则检查长度 if key[1] is not bool: # 如果有最小值但没最大值 if key[2] and not key[3]: if key[1] is str or key[1] is list: # 如果比最小值还小 if len(value) < key[2]: return error_msgs[301][ 'msg_value_type_error'] elif key[1] is int: # 如果比最小值还小 if value < key[2]: return error_msgs[301][ 'msg_value_type_error'] # 如果有最小以及最大值 elif key[2] and key[3]: if key[1] is str or key[1] is list: # 如果比最小值还小或者比最大值还大 if len(value) < key[2] or len(value) > key[3]: return error_msgs[301][ 'msg_value_type_error'] elif key[1] is int: # 如果比最小值还小或者比最大值还大 if value < key[2] or value > key[3]: return error_msgs[301][ 'msg_value_type_error'] # 如果有没有最小值但有最大值 elif not key[2] and key[3]: if key[1] is str or key[1] is list: # 如果比最大值还大 if len(value) > key[3]: return error_msgs[301][ 'msg_value_type_error'] elif key[1] is int: # 如果比最大值还大 if value > key[3]: return error_msgs[301][ 'msg_value_type_error'] return func(*args, **kwargs)
def wrapper(*args, **kwargs): # 首先检查必传参数Mail/Token if 'UserId' not in flask.request.headers: return error_msgs[302]['msg_request_params_incomplete'] user_id = flask.request.headers['UserId'] # 尝试从mysql中查询 try: api_logger.debug("准备查询账户数据") uinfo_mysql = model_mysql_userinfo.query.filter_by( userId=user_id).first() api_logger.debug("账户数据查询成功") except Exception as e: api_logger.error("账户数据查询失败,失败原因:" + repr(e)) return error_msgs[500]['msg_db_error'] else: # 如果mysql中未查询到 if uinfo_mysql is None: return error_msgs[201]['msg_no_user'] # 如果mysql中查询到了 else: # 判断账户状态 if uinfo_mysql.userStatus == 0: return error_msgs[201]['msg_need_register'] elif uinfo_mysql.userStatus == -1: return error_msgs[201]['msg_user_forbidden'] elif uinfo_mysql.userStatus != 1: return error_msgs[201]['msg_status_error'] # 检查通过,执行应用逻辑 return func(*args, **kwargs)
def check_token(userId, token): # 去缓存的token中查询Mail,不存在的话即为从来没登陆过 # redis查询无错误信息,不作try处理 api_logger.debug("准备查询缓存token数据") tdata = model_redis_usertoken.query(userId) if tdata is None: api_logger.debug("缓存token数据为空") return False else: api_logger.debug("缓存token数据存在") # 格式化缓存基础信息内容 try: t = json.loads(tdata.decode("utf8")) api_logger.debug("缓存token数据json格式化成功") except Exception as e: api_logger.error("缓存token数据json格式化失败,失败原因:" + repr(e)) return False # 判断是否一致且有效 # 判断是否过期 if token != t["userToken"]: return False elif datetime.datetime.strptime( t["validTime"], "%Y-%m-%d %H:%M:%S") < datetime.datetime.now(): return False # 检查通过,返回True return True
def check_code(cls, userid, code, operationid): # 校验账户的操作记录 # 查询mysql try: rdata_mysql = model_mysql_useroperationrecord.query.filter_by( userId=userid, operationId=operationid, recordStatus=0 ).first() except Exception as e: logmsg = "数据库中账户操作记录读取失败,失败原因:" + repr(e) api_logger.error(logmsg) return None, None # 如果未查询到 if rdata_mysql is None: return False, None # 如果查询到了 else: record_code = rdata_mysql.recordCode record_validtime = rdata_mysql.recordValidTime # 如果不一致 if code != record_code: return False, None elif datetime.datetime.now() > record_validtime: return True, 0 else: return True, 1
def key_project_put(): # 初始化返回内容 response_json = {"code": 200, "msg": "数据修改成功", "data": None} # 取出必传入参 request_user_id = flask.request.headers['UserId'] project_name = flask.request.json['name'] project_description = flask.request.json['description'] project_coverOssPath = flask.request.json['coverOssPath'] project_id = flask.request.json['id'] # 查询项目名称是否存在 try: mysql_project = model_mysql_project.query.filter( model_mysql_project.id == project_id, model_mysql_project.status == 1).first() except Exception as e: api_logger.error("项目数据读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] if mysql_project is None: return route.error_msgs[201]['msg_no_project'] else: mysql_project.name = project_name mysql_project.description = project_description mysql_project.coverOssPath = project_coverOssPath try: mysqlpool.session.commit() except Exception as e: api_logger.error("项目数据更新失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] # 最后返回内容 return response_json
def get_task_init_logs(task_id, query_offset=0, query_limit=200): """ 至mongodb中获取re_task_id对应的初始化日志条目,并将条目组装为单个字符串 顺序获取 每次获取N条,并记录下当前获取的条目数 循环请求时仅返回批次数据,之前返回的不再返回,保证接口每批次返回数据较小 :param task_id: 测试任务id :param query_offset: 分页查询偏移量 :param query_limit: 分页查询行数 :return: True/False-方法执行结果 initLog/None-测试任务初始化日志 count/None-数据总数 """ try: log_query = mongodb_tasklog_pool['task%s_init' % task_id].find({}, { "_id": 0, "log": 1 }).skip(query_offset).limit(query_limit) except Exception as e: api_logger.error("测试任务:%s初始化日志数据读取失败,失败原因:%s" % (task_id, repr(e))) return False, None, -1 else: api_logger.debug("测试任务:%s初始化日志数据读取成功" % task_id) log_list = [lq['log'] for lq in list(log_query)] return True, log_list, log_query.count()
def key_project_delete(): # 初始化返回内容 response_json = {"code": 200, "msg": "数据删除成功", "data": None} # 取出入参 project_user_id = flask.request.headers['UserId'] project_id = flask.request.args['id'] # 判断项目是否存在 try: mysql_project_info = model_mysql_project.query.filter( model_mysql_project.id == project_id, model_mysql_project.userId == project_user_id, model_mysql_project.status == 1).first() api_logger.debug("账户基础信息读取成功") except Exception as e: api_logger.error("账户基础信息读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_project_info is None: return route.error_msgs[201]['msg_no_project'] else: mysql_project_info.status = -1 mysqlpool.session.commit() # 最后返回内容 return response_json
def get_snap_table_data(plan_id): # 于redis中尝试读取计划的快照缓存 cache_table_bytes = modle_redis_apitestplanworktable.query_table( plan_id=plan_id) # 如果缓存中没有,就去mysql读取并且同步至redis # 这里类型错误,数组为空 if cache_table_bytes is None: # 读取mysql中对应plan的最新snap try: mysql_snap_data = model_mysql_tablesnap.query.filter( and_(model_mysql_tablesnap.planId == plan_id, # model_mysql_tablesnap.status == 1 )).order_by( model_mysql_tablesnap.id.desc()).limit(1).first() api_logger.debug("model_mysql_tablesnap数据读取成功") except Exception as e: api_logger.error("model_mysql_tablesnap数据读取失败,失败原因:" + repr(e)) return False, None else: if mysql_snap_data: # 如果查询到了,则同步至redis redis_set_flag = True redis_set_flag = modle_redis_apitestplanworktable.set_table( plan_id, mysql_snap_data.table) redis_set_flag = modle_redis_apitestplanworktable.set_time( plan_id) if redis_set_flag: return True, mysql_snap_data.table else: return False, None else: # 如果无记录,说明是新测试计划,此时需要在mysql中新增空记录,然后一并同步至redis # 新增status为1的snap,内容为空 new_blank_snap = model_mysql_tablesnap( status=1, planId=plan_id, snapAddTime=datetime.datetime.now(), table="[]") try: mysqlpool.session.add(new_blank_snap) mysqlpool.session.commit() except Exception as e: api_logger.error("new_blank_snap数据写入失败,失败原因:" + repr(e)) return False, None else: # 然后再讲空数据同步至redis redis_set_flag = True redis_set_flag = modle_redis_apitestplanworktable.set_table( plan_id, new_blank_snap.table) redis_set_flag = modle_redis_apitestplanworktable.set_time( plan_id) if redis_set_flag: return True, new_blank_snap.table else: return False, None # 如果有 else: return True, cache_table_bytes.decode("utf8")
def plan_worktable_snap_plugin_delete(): # 初始化返回内容 response_json = {"code": 200, "msg": "操作成功", "data": {}} # 取出 mail = flask.request.headers['Mail'] plan_id = int(flask.request.args['plan_id']) pid = int(flask.request.args['pid']) result, msg = check_plan_owner(mail, plan_id) if result is None or result is False: return msg resource_path = appconfig.get("task", "filePutDir") resource_path = resource_path[:-1] if resource_path[ -1] == "/" else resource_path resource_path = "%s/%s/%s" % (resource_path, plan_id, pid) if os.path.exists(resource_path) and os.path.isdir(resource_path): try: shutil.rmtree(resource_path) except Exception as e: api_logger.error("文件删除失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_file_error'] # 最后返回内容 return response_json
def key_projectrole_get(): # 初始化返回内容 response_json = {"code": 200, "msg": "数据获取成功", "data": []} #查询符合条件的项目id try: mysql_projectrole_info = model_mysql_roleinfo.query.filter( model_mysql_roleinfo.roleIsAdmin == 0, model_mysql_roleinfo.roleStatus == 1).all() except Exception as e: api_logger.error("model_mysql_depository,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] if mysql_projectrole_info is None: return route.error_msgs[201]['msg_no_data'] else: for mqit in mysql_projectrole_info: response_json["data"].append({ "id": mqit.roleId, "name": mqit.roleName, "description": mqit.roleDescription, }) # 最后返回内容 return response_json
def wrapper(*args, **kwargs): # 首先检查必传参数Mail/Token if 'UserId' not in flask.request.headers or 'Token' not in flask.request.headers: return error_msgs[302]['msg_request_params_incomplete'] user_id = flask.request.headers['UserId'] user_token = flask.request.headers['Token'] # 然后检查token是否正确 # 去缓存的token中查询Mail,不存在的话即为从来没登陆过 # redis查询无错误信息,不作try处理 api_logger.debug("准备查询缓存token数据") tdata = model_redis_usertoken.query(user_id) if tdata is None: api_logger.debug("缓存token数据为空") return error_msgs[201]['msg_before_login'] else: api_logger.debug("缓存token数据存在") # 格式化缓存基础信息内容 try: t = json.loads(tdata.decode("utf8")) api_logger.debug("缓存token数据json格式化成功") except Exception as e: api_logger.error("缓存token数据json格式化失败,失败原因:" + repr(e)) return error_msgs[500]['msg_json_format_fail'] # 判断是否一致且有效 # 判断是否过期 if user_token != t["userToken"]: return error_msgs[401]['msg_token_wrong'] elif datetime.datetime.strptime( t["validTime"], "%Y-%m-%d %H:%M:%S") < datetime.datetime.now(): return error_msgs[401]['msg_token_expired'] # 检查通过,执行应用逻辑 return func(*args, **kwargs)
def user_status_put(): # 初始化返回内容 response_json = { "code": 200, "msg": "", "data": {} } # 取出传入参数值 requestvalue_userid = flask.request.json["user_id"] requestvalue_status = flask.request.json["status"] # 4.校验所操作的账户是否存在 # 5.校验所操作的账户所属角色是否是超级管理员 try: ur_data = mysqlpool.session.query( model_mysql_userinfo, model_mysql_userinfo.userId, model_mysql_userinfo.userStatus, model_mysql_roleinfo.roleIsAdmin ).join( model_mysql_roleinfo, model_mysql_roleinfo.roleId == model_mysql_userinfo.userRoleId, isouter=True ).filter( model_mysql_userinfo.userId == requestvalue_userid ).first() except Exception as e: logmsg = "数据库中账号数据读取失败,失败原因:" + repr(e) api_logger.error(logmsg) return route.error_msgs[500]['msg_db_error'] else: if ur_data and ur_data.roleIsAdmin in [0, None]: pass elif ur_data and ur_data.roleIsAdmin == 1: return route.error_msgs[201]['msg_user_is_admin'] elif ur_data and ur_data.userStatus in [-2, 0]: return route.error_msgs[201]['msg_user_cannot_operate'] else: return route.error_msgs[201]['msg_no_user'] # 6.修改mysql账户状态 try: u_data = model_mysql_userinfo.query.filter( model_mysql_userinfo.userId == requestvalue_userid ).first() logmsg = "数据库中账号数据读取成功" api_logger.debug(logmsg) except Exception as e: logmsg = "数据库中账号数据读取失败,失败原因:" + repr(e) api_logger.error(logmsg) return route.error_msgs[500]['msg_db_error'] else: u_data.userStatus = requestvalue_status mysqlpool.session.commit() # 返回成功信息 response_json["msg"] = "操作成功" # 最后返回内容 return response_json
def key_catalogues_get(): # 初始化返回内容 response_json = {"code": 200, "msg": "数据获取成功", "data": []} # 查询基础信息 try: mysql_subjects_info = model_mysql_catalogue.query.filter().all() except Exception as e: api_logger.error("表model_mysql_subject读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: for mpti in mysql_subjects_info: response_json["data"].append({ "id": mpti.catalogueId, "name": mpti.catalogueName, "createTime": str(mpti.catalogueCreateTime), "updateTime": str(mpti.catalogueUpdateTime), }) # 最后返回内容 return response_json
def role_info_list_get(): # 初始化返回内容 response_json = { "code": 200, "msg": "", "data": { "total": 0, "role_list": {} } } # 取出传入参数值 page_num = int(flask.request.args['page_num']) per_page = int(flask.request.args['per_page']) # 查询角色,包括id/name/canmanage # 根据角色id,查询角色下关联的账户,判断角色是否可删除 try: rinfo_mysql = mysqlpool.session.query( model_mysql_roleinfo, model_mysql_roleinfo.roleId, model_mysql_roleinfo.roleName, model_mysql_roleinfo.roleIsAdmin).limit( # (requestvalue_num - 1) * requestvalue_per, per_page).offset((page_num - 1) * per_page).all() except Exception as e: logmsg = "数据库中角色列表读取失败,失败原因:" + repr(e) api_logger.error(logmsg) return route.error_msgs[500]['msg_db_error'] else: # 构造role_list for r in rinfo_mysql: rsome = { "id": r.roleId, "name": r.roleName, "can_manage": True if r.roleIsAdmin == 0 else False } response_json["data"]["role_list"][r.roleId] = rsome try: total_mysql = mysqlpool.session.query( func.count( model_mysql_roleinfo.roleId).label(name="roleNum")).first() logmsg = "数据库中角色总数读取成功" api_logger.debug(logmsg) except Exception as e: logmsg = "数据库中角色总数读取失败,失败原因:" + repr(e) api_logger.error(logmsg) return route.error_msgs[500]['msg_db_error'] else: # 构造total response_json["data"]["total"] = total_mysql.roleNum # 8.返回成功信息 response_json["msg"] = "操作成功" # 最后返回内容 return response_json
def set_snap_table_data(plan_id, table): # 从缓存中获取时间 cache_time_bytes = modle_redis_apitestplanworktable.query_time( plan_id=plan_id) # 如果时间获取成功,则比较当前时间和缓存的时间 if cache_time_bytes is not None: cache_time = datetime.datetime.strptime( cache_time_bytes.decode("utf8"), "%Y-%m-%d %H:%M:%S") # 如果没有超出15分钟(可配置),则仅刷新redis中内容 if (datetime.datetime.now() - cache_time).seconds <= int( appconfig.get("task", "snapSyncInterval")): modle_redis_apitestplanworktable.set_table(plan_id, table) return True # 如果超出了15分钟(可配置),则先刷新redis中内容与时间,再同步至mysql生成快照,且更新时间 else: redis_set_flag = True redis_set_flag = modle_redis_apitestplanworktable.set_table( plan_id, table) redis_set_flag = modle_redis_apitestplanworktable.set_time(plan_id) if redis_set_flag: # mysql中新增snap # 将status为1的snap全部置为失效 try: model_mysql_tablesnap.query.filter( and_(model_mysql_tablesnap.planId == plan_id, model_mysql_tablesnap.status == 1)).update( {"status": 0}) mysqlpool.session.commit() except Exception as e: api_logger.error("model_mysql_tablesnap数据更新失败,失败原因:" + repr(e)) return False else: # 新增status为1的snap,内容即为接口传参内容 new_snap = model_mysql_tablesnap( status=1, planId=plan_id, snapAddTime=datetime.datetime.now(), table=table) try: mysqlpool.session.add(new_snap) mysqlpool.session.commit() except Exception as e: api_logger.error("new_snap数据写入失败,失败原因:" + repr(e)) return False else: return True else: return False # 如果时间获取失败,则直接将内容写入redis else: redis_set_flag = True redis_set_flag = modle_redis_apitestplanworktable.set_table( plan_id, table) redis_set_flag = modle_redis_apitestplanworktable.set_time(plan_id) return redis_set_flag
def role_all_permission_get(): """ 获取所有角色权限配置清单-api路由 ----校验 1.校验传参 2.校验账户是否存在 3.校验账户操作令牌 ----操作 4.于数据库中查询全量配置清单 """ # 初始化返回内容 response_json = { "code": 200, "msg": "", "data": { "permission": { "all": {} } } } # 4.于数据库中查询全量权限配置清单 try: allp_mysql = model_mysql_functioninfo.query.order_by( model_mysql_functioninfo.functionType.asc()).all() except Exception as e: logmsg = "数据库中角色列表读取失败,失败原因:" + repr(e) api_logger.error(logmsg) return route.error_msgs[500]['msg_db_error'] else: # 构造角色权限配置清单 for ap in allp_mysql: # 如果此行记录为page,则记录 if ap.functionType == 1: response_json["data"]["permission"]["all"][ap.functionId] = { "id": ap.functionId, "name": ap.functionName, "alias": ap.functionAlias, "description": ap.functionDescription, "component": {} } else: # 如果为组件,则根据rootId判断添加至哪个page的component中 response_json["data"]["permission"]["all"][ ap.rootId]['component'][ap.functionId] = { "id": ap.functionId, "name": ap.functionName, "alias": ap.functionAlias, "description": ap.functionDescription } # 5.返回成功信息 response_json["msg"] = "操作成功" # 最后返回内容 return response_json
def user_info_get(): # 初始化返回内容 response_json = { "code": 200, "msg": "", "data": { "user_id": '', "nick_name": '', "mail_address": '', "new_mail_address": '', "introduction": '', "icon_url": '' } } # 取出传入参数值 requestvalue_id = flask.request.args["user_id"] # 尝试查询mysql try: uinfo_mysql = mysqlpool.session.query( model_mysql_userinfo.userId, model_mysql_userinfo.userNickName, model_mysql_userinfo.userEmail, model_mysql_userinfo.userNewEmail, model_mysql_userinfo.userIntroduction, model_mysql_userinfo.userHeadIconUrl, model_mysql_useroperationrecord.recordId ).outerjoin( model_mysql_useroperationrecord, and_( model_mysql_userinfo.userId == model_mysql_useroperationrecord.userId, model_mysql_useroperationrecord.recordStatus == 0, model_mysql_useroperationrecord.operationId == 3, model_mysql_useroperationrecord.recordValidTime > func.now() ) ).filter( model_mysql_userinfo.userId == requestvalue_id ).first() except Exception as e: logmsg = "数据库中账户信息读取失败,失败原因:" + repr(e) api_logger.error(logmsg) return route.error_msgs[500]['msg_db_error'] else: response_json["data"]["user_id"] = uinfo_mysql.userId response_json["data"]["nick_name"] = uinfo_mysql.userNickName response_json["data"]["mail_address"] = uinfo_mysql.userEmail response_json["data"]["new_mail_address"] = uinfo_mysql.userNewEmail if uinfo_mysql.recordId else None response_json["data"]["introduction"] = uinfo_mysql.userIntroduction response_json["data"]["icon_url"] = uinfo_mysql.userHeadIconUrl # 8.返回成功信息 response_json["msg"] = "操作成功" # 最后返回内容 return response_json
def key_catalogues_post(): # 初始化返回内容 response_json = {"code": 200, "msg": "目录归档成功", "data": None} # 取出必传入参 request_user_id = flask.request.headers['UserId'] subject_name = flask.request.json['subjectName'] subject_logo_path = flask.request.json['subjectLogoPath'] subject_description = flask.request.json['subjectDescription'] subject_open_level = flask.request.json['subjectOpenLevel'] # 判断user_id是否存在 try: mysql_userinfo = model_mysql_subject.query.filter( model_mysql_subject.userId == request_user_id).first() api_logger.debug("账户基础信息读取成功") except Exception as e: api_logger.error("账户基础信息读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_userinfo is None: return route.error_msgs[201]['msg_no_user'] # 查询项目名称是否存在 try: mysql_subject = model_mysql_subject.query.filter( model_mysql_subject.subjectName == subject_name).first() except Exception as e: api_logger.error("测试计划类型读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_subject is None: pass else: return route.error_msgs[201]['msg_exit_subject'] #获取当前id """ 插入项目计划数据 """ new_subject_info = model_mysql_subject( userId=request_user_id, subjectName=subject_name, subjectLogoPath=subject_logo_path, subjectOpenLevel=subject_open_level, subjectDescription=subject_description if subject_description else None, subjectStatus=1, ) mysqlpool.session.add(new_subject_info) mysqlpool.session.commit() # 最后返回内容 return response_json
def get_single_collection(taskid, plugin_id, skip_num): try: log_query = mongodb_tasklog_pool['task%s_run' % taskid].find( {'id': plugin_id}, {"_id": 0} ).skip(skip_num).limit(1) except Exception as e: api_logger.error("测试任务:%s运行日志数据读取失败,失败原因:%s" % (taskid, repr(e))) return False, None else: api_logger.debug("测试任务:%s运行日志数据读取成功" % taskid) return True, list(log_query)
def key_caseConflict_get(): # 初始化返回内容 response_json = {"code": 200, "msg": "数据获取成功", "data": []} # 取出必传入参 project_id = flask.request.args['projectId'] # 判断项目是否存在,并且发起了评审,并获取仓库id try: mysql_project_info = model_mysql_project.query.filter( model_mysql_project.id == project_id, model_mysql_project.status == 2).first() except Exception as e: api_logger.error("读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_project_info is None: return response_json # 判断项目冲突是否存在 try: mysql_conflict_info = model_mysql_projectArchivePendingCase.query.filter( model_mysql_projectArchivePendingCase.projectId == project_id, model_mysql_projectArchivePendingCase.status == 1).all() except Exception as e: api_logger.error("读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_conflict_info is None: return response_json # 构造冲突结果返回信息 for mq in mysql_conflict_info: originalCase = [] projectIdCase = [] otherCase = [] originalCase.append(createcase(mq.originalCaseId)) projectIdCase.append(createcase(mq.projectIdCaseId)) otherCase.append(createcase(mq.otherCaseId)) response_json["data"].append({ "id": mq.id, "projectId": project_id, "projectName": mysql_project_info.name, "originalCase": originalCase, "projectIdCase": projectIdCase, "otherCase": otherCase, "status": mq.status }) return response_json
def plan_worktable_snap_plugin_file_post(): # 初始化返回内容 response_json = { "code": 200, "msg": "操作成功", "data": { "name": "", "uuid": "" } } # 取出 mail = flask.request.headers['Mail'] plan_id = flask.request.form['plan_id'] pid = flask.request.form['id'] result, msg = check_plan_owner(mail, plan_id) if result is None or result is False: return msg # 得到uuid转换后的文件名 request_file = flask.request.files['file'] response_json['data']['name'] = request_file.filename response_json['data']['uuid'] = "%s.%s" % ( uuid.uuid1().hex, request_file.filename.split('.')[-1]) # 将文件存储至指定路径下 # 按照:指定路径/plan_id/id下 resource_path = appconfig.get("task", "filePutDir") resource_path = resource_path[:-1] if resource_path[ -1] == "/" else resource_path resource_path = "%s/%s/%s" % (resource_path, plan_id, pid) # 根据配置文件中的路径,判断账户私有文件夹是否存在 if os.path.exists(resource_path) is False or os.path.isdir( resource_path) is False: # 新建文件夹 try: os.makedirs(resource_path) except Exception as e: api_logger.error("文件夹创建失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_file_error'] # 将文件保存至指定路径 try: request_file.save("%s/%s" % (resource_path, response_json['data']['uuid'])) except Exception as e: api_logger.error("文件保存失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_file_error'] # 最后返回内容 return response_json
def plan_post(): # 初始化返回内容 response_json = {"code": 200, "msg": "操作成功", "data": {}} # 取出必传入参 user_id = flask.request.json['userId'] plan_type = flask.request.json['planType'] plan_title = flask.request.json['planTitle'] open_level = flask.request.json['openLevel'] plan_description = flask.request.json['planDescription'] # 判断user_id是否存在 try: mysql_userinfo = model_mysql_userinfo.query.filter( model_mysql_userinfo.userId == user_id).first() api_logger.debug("账户基础信息读取成功") except Exception as e: api_logger.error("账户基础信息读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_userinfo is None: return route.error_msgs[201]['msg_no_user'] # 查询测试计划类型是否存在 try: mysql_plantype = model_mysql_plantype.query.filter( model_mysql_plantype.typeId == plan_type).first() except Exception as e: api_logger.error("测试计划类型读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_plantype is None: return route.error_msgs[201]['msg_no_plan_type'] """ 插入测试计划数据 关于测试计划所有者类型: 0 个人 1 团队 """ new_plan_info = model_mysql_planinfo( ownerId=user_id, planType=plan_type, planTitle=plan_title, planDescription=plan_description if plan_description else None, planOpenLevel=open_level, planOwnerType=0) mysqlpool.session.add(new_plan_info) mysqlpool.session.commit() # 最后返回内容 return response_json
def key_subject_get(): # 初始化返回内容 response_json = { "code": 200, "msg": "数据获取成功", "data": { "id": 0, "name": None, "logoPath": None, "description": None, "status": 1 } } subject_user_id = None # 取出入参 request_user_id = flask.request.headers['UserId'] subject_id = flask.request.args['subjectId'] # 查询项目基础信息,并取出所属者账户id try: mysql_subject_info = model_mysql_subject.query.filter( model_mysql_subject.subjectId == subject_id).first() except Exception as e: api_logger.error("model_mysql_subjectinfo数据读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] else: if mysql_subject_info is None: return route.error_msgs[201]['msg_no_subject'] else: subject_user_id = mysql_subject_info.userId response_json['data']['id'] = mysql_subject_info.subjectId response_json['data']['name'] = mysql_subject_info.subjectName response_json['data'][ 'logoPath'] = mysql_subject_info.subjectLogoPath response_json['data'][ 'description'] = mysql_subject_info.subjectDescription response_json['data']['status'] = mysql_subject_info.subjectStatus # 根据项目状态以及操作者id/计划拥有者id判断返回内容 if request_user_id == subject_user_id: pass else: if mysql_subject_info.subjectStatus in (1, 2): pass else: return route.error_msgs[201]['msg_no_subject'] # 最后返回内容 return response_json
def key_projectlist_get(): # 初始化返回内容 response_json = { "code": 200, "msg": "数据获取成功", "data": [] } project_id = flask.request.args['id'] # 查询符合条件的项目并获得仓库id try: mysql_project_info = model_mysql_project.query.filter( model_mysql_project.id == project_id, model_mysql_project.status != -1 ).first() except Exception as e: api_logger.error("model_mysql_depository,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] if mysql_project_info is None: print(111) return route.error_msgs[201]['msg_no_project'] else: depository_Id = mysql_project_info.depositoryId # 查询符合条件的项目 try: mysql_projects_info = model_mysql_project.query.filter( model_mysql_project.depositoryId == depository_Id, model_mysql_project.status != -1, model_mysql_project.id != project_id ).all() except Exception as e: api_logger.error("model_mysql_depository,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] if mysql_projects_info is None: print(2222) return route.error_msgs[201]['msg_no_project'] else: for mqti in mysql_projects_info: response_json["data"].append({ "id":mqti.id, "name":mqti.name, "decription":mqti.description, "coverOssPath":mqti.coverOssPath }) # 最后返回内容 return response_json
def key_catalogue_get(): # 初始化返回内容 response_json = { "code": 200, "msg": "数据获取成功", "data": { "catalogueId": 1, "catalogueName": None, "createTime": None, "updateTime": None } } # 取出入参 catalogue_id = flask.request.args['catalogueId'] subject_id = flask.request.args['subjectId'] # 查询项目基础信息,并取出所属者账户id try: mysql_catalogue_info = model_mysql_catalogue.query.filter( model_mysql_catalogue.catalogueId == catalogue_id).first() except Exception as e: api_logger.error("model_mysql_subjectinfo数据读取失败,失败原因:" + repr(e)) return route.error_msgs[500]['msg_db_error'] if mysql_catalogue_info is None: return route.error_msgs[201]['msg_no_catalogue'] elif mysql_catalogue_info.subjectId != int(subject_id): return route.error_msgs[201]['msg_data_error'] else: response_json['data']['catalogueId'] = mysql_catalogue_info.catalogueId response_json['data'][ 'catalogueName'] = mysql_catalogue_info.catalogueName response_json['data']['createTime'] = str( mysql_catalogue_info.catalogueCreateTime) response_json['data']['updateTime'] = str( mysql_catalogue_info.catalogueUpdateTime) # 根据项目状态以及操作者id/计划拥有者id判断返回内容 if mysql_catalogue_info.catalogueStatus in (1, 2): pass else: return route.error_msgs[201]['msg_no_catalogue'] # 最后返回内容 return response_json