def reorder_relation(relation_id, new_order):
"""
调整某个已有interface的order
同时将其他影响范围内的interface的order全部加一或者减一
:return:
"""
with session_scope() as session:
relation = session.query(UseCaseInterfaceRelation).filter_by(
id=relation_id).one()
current_order = relation.order
use_case_id = relation.use_case_id
if current_order == new_order:
return
elif current_order < new_order:
session\
.query(UseCaseInterfaceRelation)\
.filter_by(use_case_id=use_case_id)\
.filter(UseCaseInterfaceRelation.order > current_order)\
.filter(UseCaseInterfaceRelation.order <= new_order)\
.update({'order': UseCaseInterfaceRelation.order - 1})
elif current_order > new_order:
session\
.query(UseCaseInterfaceRelation)\
.filter_by(use_case_id=use_case_id)\
.filter(UseCaseInterfaceRelation.order < current_order)\
.filter(UseCaseInterfaceRelation.order >= new_order)\
.update({'order': UseCaseInterfaceRelation.order + 1})
session\
.query(UseCaseInterfaceRelation)\
.filter_by(id=relation_id)\
.update({'order': new_order})
def add_relation(use_case_id, interface_id, order=None):
"""
将某interface与use_case关联
如未传入order则加入到最后
如传入order则大于当前order的全部加一
:param use_case_id: use_case id
:param interface_id: interface id
:param order: interface顺序，如果为空加入到最后
:return:
"""
with session_scope() as session:
if not order:
order = get_max_order(use_case_id) + 1
else:
session\
.query(UseCaseInterfaceRelation)\
.filter_by(use_case_id=use_case_id)\
.filter(UseCaseInterfaceRelation.order >= order)\
.update({'order': UseCaseInterfaceRelation.order + 1})
relation = UseCaseInterfaceRelation(use_case_id=use_case_id,
interface_id=interface_id,
order=order)
session.add(relation)
session.flush()
return relation.id
def del_environment_line_info(**kwargs):
info_list = kwargs.get('id')
if not isinstance(info_list, list):
info_list = [info_list]
with session_scope() as session:
for line_id in info_list:
session.query(EnvironmentInfo).filter_by(id=line_id).delete(synchronize_session=False)
def query_line_relation(**kwargs):
with session_scope() as session:
busines_query = session.query(BusinessLine).filter_by(**kwargs).filter_by(status=1)
system_query = session.query(SystemLine).filter_by(**kwargs).filter_by(status=1)
function_query = session.query(FunctionLine).filter_by(**kwargs).filter_by(status=1)
business_line_dict = {}
for query in busines_query:
business_line_info = query.to_dict()
business_line_dict[business_line_info['id']] = business_line_info
system_line_dict = {}
for query in system_query:
system_line_info = query.to_dict()
system_line_dict[system_line_info['id']] = system_line_info
function_dict = {}
for function_obj in function_query:
function_info = function_obj.to_dict()
if not function_info['id']:
continue
system_line_id = function_info['system_line_id']
business_line_id = system_line_dict[system_line_id].get('business_line_id')
business_name = business_line_dict[business_line_id].get('business_name')
system_name = system_line_dict[system_line_id].get('system_name')
function_name = function_info['function_name']
function_dict[function_info['id']] = {'business_name': business_name, 'system_name': system_name,
'function_name': function_name, 'system_line_id': system_line_id,
'business_line_id': business_line_id,
'function_line_id': function_info['id']}
return function_dict
def del_environment_line_info(**kwargs):
info_list = kwargs.get('id')
if not isinstance(info_list, list):
info_list = [info_list]
with session_scope() as session:
for line_id in info_list:
session.query(EnvironmentInfo).filter_by(id=line_id).update(
{'status': 0})
def get_batch_use_case_relation(**kwargs):
with session_scope() as session:
query = session.query(BatchUseCaseRelation).filter_by(
**kwargs).filter_by(status=1)
batch_use_case_relation_list = [
b_use_case.to_dict() for b_use_case in query
]
return batch_use_case_relation_list
def del_business_line(**kwargs):
business_id = kwargs.get('id')
if not isinstance(business_id, list):
business_id = [business_id]
with session_scope() as session:
query = session.query(BusinessLine)
query.filter(BusinessLine.id.in_(business_id)).delete(synchronize_session=False)
return business_id
def get_encryption_id_to_name():
with session_scope() as session:
query = session.query(Encryption).all()
encryption_id_to_name = {}
for encryption in query:
encryption_id_to_name[
encryption.id] = encryption.encryption_method_name
return encryption_id_to_name
def del_email_function_relation(email_id, function_ids):
function_ids = [function_ids] if not isinstance(function_ids, list) else function_ids
with session_scope() as session:
for function_id in function_ids:
session.query(EFR).\
filter_by(function_id=function_id).\
filter_by(email_id=email_id).\
update({'status': 0})
def del_function_line(**kwargs):
function_id = kwargs.get('id')
if not isinstance(function_id, list):
function_id = [function_id]
with session_scope() as session:
query = session.query(FunctionLine)
query.filter(FunctionLine.id.in_(function_id)).delete(synchronize_session=False)
return function_id
def del_system_line(**kwargs):
system_line_id = kwargs.get('id')
if not isinstance(system_line_id, list):
system_line_id = [system_line_id]
with session_scope() as session:
query = session.query(SystemLine)
query.filter(SystemLine.id.in_(system_line_id)).delete(synchronize_session=False)
return system_line_id
def modify_case_parameter_relation(**kwargs):
"""
更新用例关联参数信息
:param kwargs:
:return:
"""
with session_scope() as session:
id = kwargs.pop('id')
session.query(UseCaseParameterRelation).filter_by(id=id).update(kwargs)
def del_case_parameter_relation(**kwargs):
"""
删除用例关联参数
:param kwargs:
:return:
"""
with session_scope() as session:
session.query(UseCaseParameterRelation).filter_by(**kwargs).update(
{'status': 0})
def update_eval_relation(id, eval_string):
"""
获取某use_case下interface的最大eval_string值
:param ： id, eval_string
:return:
"""
with session_scope() as session:
session.query(UseCaseInterfaceRelation).filter_by(id=id).update(
{'eval_string': eval_string})
def get_email_batch():
with session_scope() as session:
relation = session.query(EBR).filter_by(status=1)
email_to_batchs = {}
for m in relation:
if m.email_id in email_to_batchs:
email_to_batchs[m.email_id].append(m.batch_id)
else:
email_to_batchs[m.email_id] = [m.batch_id]
return email_to_batchs
def get_use_case_with_function_id(function_line_list):
with session_scope() as session:
use_case_with_function_line_dict = {}
for function_info in function_line_list:
function_id = function_info.get('id')
query = session.query(UseCase).filter_by(function_id=function_id).filter_by(status=1).\
order_by(UseCase.create_time.desc())
use_case_list = [use_case.to_dict() for use_case in query]
use_case_with_function_line_dict[function_id] = use_case_list
return use_case_with_function_line_dict
def get_multi_use_case(use_case_list):
with session_scope() as session:
query = session.query(UseCase).filter(UseCase.id.in_(use_case_list)).\
order_by(UseCase.create_time.desc())
use_case_dict = {}
for use_case in query:
use_case_info = use_case.to_dict()
use_case_id = use_case_info['id']
use_case_dict[use_case_id] = use_case_info
return use_case_dict
def modify_interface_delay_relation(relation_id, interface_delay):
"""
更新关系表中的interface_delay
:param relation_id:
:param interface_delay:
:return:
"""
with session_scope() as session:
session.query(UseCaseInterfaceRelation).filter_by(
id=relation_id).update({'interface_delay': interface_delay})
def get_interface(**kwargs):
if 'interface_name' not in kwargs:
interface_name = ''
else:
interface_name = kwargs.pop('interface_name')
with session_scope() as session:
query = session.query(Interface).filter(Interface.interface_name.like('%{0}%'.format(interface_name))).\
filter_by(**kwargs).filter_by(status=1).order_by(Interface.update_time.desc())
interface_list = [interface.to_dict() for interface in query]
return interface_list
def query_email_by_function_id(function_id):
with session_scope() as session:
q = session.query(EFR).\
filter_by(function_id=function_id).\
filter_by(status=1)
email_id_list = [email.email_id for email in q]
email = session.query(Email).\
filter(Email.id.in_(email_id_list)).\
filter_by(status=1)
return [m.to_dict() for m in email]
def add_case_parameter_relation(**kwargs):
"""
添加用例关联参数信息
:param kwargs:
:return:
"""
with session_scope() as session:
use_case_parameter = UseCaseParameterRelation(**kwargs)
session.add(use_case_parameter)
session.flush()
return use_case_parameter.id
def get_case_parameter_relation(**kwargs):
"""
查询用例关联参数信息
:param kwargs:
:return:
"""
with session_scope() as session:
query = session.query(UseCaseParameterRelation).filter_by(
**kwargs).filter_by(status=1)
session.expunge_all()
parameter_list = [s_param.to_dict() for s_param in query]
return parameter_list
def del_use_case(**kwargs):
"""
删除use_case
同时将所有该use_case的关联关系清除
:param kwargs:
:return:
"""
with session_scope() as session:
id = kwargs.pop('id')
session.query(UseCase).filter_by(id=id).update({'status': 0})
session.query(BatchUseCaseRelation).filter_by(use_case_id=id).update(
{'status': 0})
session.query(UseCaseInterfaceRelation).filter_by(
use_case_id=id).update({'status': 0})
def get_relation(**kwargs):
"""
根据传入参数不同获取不同信息：
use_case_id：获取某个use_case包含的interface
interface_id：获取某个interface关联的use_case
:param: use_case_id:
:return:
"""
with session_scope() as session:
query = session\
.query(UseCaseInterfaceRelation)\
.filter_by(**kwargs)\
.filter_by(status=1).order_by(UseCaseInterfaceRelation.order)
session.expunge_all()
relation_list = [s_relation.to_dict() for s_relation in query]
return relation_list
def get_max_order(use_case_id):
"""
获取某use_case下interface的最大order数
:param use_case_id: use_case id
:return: 最大order数
"""
with session_scope() as session:
max_order_relation = session\
.query(UseCaseInterfaceRelation)\
.filter_by(use_case_id=use_case_id, status=1)\
.order_by(desc(UseCaseInterfaceRelation.order))\
.first()
if not max_order_relation:
return 0
else:
return max_order_relation.order
def del_relation(relation_id):
"""
删除use_case与interface关系
如果有order大于当前删除order的，全部减一
:param relation_id: relation id
:return:
"""
with session_scope() as session:
relation = session.query(UseCaseInterfaceRelation).filter_by(
id=relation_id).one()
current_order = relation.order
use_case_id = relation.use_case_id
session.query(UseCaseInterfaceRelation).filter_by(
id=relation_id).update({'status': 0})
session\
.query(UseCaseInterfaceRelation)\
.filter_by(use_case_id=use_case_id)\
.filter(UseCaseInterfaceRelation.order > current_order)\
.update({'order': UseCaseInterfaceRelation.order - 1})
def add_email_account(**kwargs):
with session_scope() as session:
email = Email(**kwargs)
session.add(email)
session.flush()
return email.id
def del_email_account(**kwargs):
email_id = kwargs.pop('id')
with session_scope() as session:
session.query(Email).filter_by(id=email_id).delete(
synchronize_session=False)
def query_email_account():
with session_scope() as session:
query = session.query(Email)
email_list = [email.to_dict() for email in query]
return email_list
def add_test(**kwargs):
with session_scope() as session:
testObj = Test(**kwargs)
session.add(testObj)
session.flush()
