def get_model_by_project_id(project_id):
"""
获取项目对应的model(执行流程)
:param project_id:
:return:
"""
# 获取 model
model = ModelDao.get_model_by_project_id(project_id)
if model is False:
return False
# 获取 operator
operators = OperatorDao.get_operator_by_model_id(model.id)
if operators is False:
return False
# 获取 operator_type
operator_types = OperatorTypeDao.get_all_operator_type()
if operator_types is False:
return False
# TODO : 查询数据源表
operator_types_dict = dict()
for operator_type in operator_types:
operator_types_dict[operator_type.id] = operator_type
# 返回结果
config = dict()
for operator in operators:
if operator_types_dict[operator.operator_type_id].id == 5001:
data_operator_type = json.loads(
operator.operator_config)['fileUrl'][0][operator.id].split(
'/')[-1]
else:
data_operator_type = operator_types_dict[
operator.operator_type_id].type_name
config[operator.id] = {
'type': data_operator_type,
'name': operator_types_dict[operator.operator_type_id].id,
'location': json.loads(operator.operator_style)['location'],
'config': json.loads(operator.operator_config),
'next': operator.child_operator_ids.split(','),
"pre": operator.father_operator_ids.split(',')
}
model_config = json.loads(model.config)
relationship = []
for item in model_config['relationship'].split('*,'):
relationship.append(list_str_to_list(item))
config_order = json.loads(model_config['config_order'])
return {
'projectId': project_id,
'config': config,
'startNode': model.start_nodes.split(','),
'relationship': relationship,
'config_order': config_order
}
def get_run_status_by_project_id(project_id, model_execute_id):
"""
获取某次执行的状态和其中的每个算子的状态
:param project_id:
:param model_execute_id: model的执行记录ID
:return:
"""
# 获取 model
model = ModelDao.get_model_by_project_id(project_id)
if model is False:
return False
# 获取 operator
operators = OperatorDao.get_operator_by_model_id(model.id)
if operators is False:
return False
# 构造dict
id_operator_dict = {}
for operator in operators:
id_operator_dict[operator.id] = operator
# 查看此次执行记录（状态、起始节点）
model_execute_ = ModelExecuteDao.get_model_execute_by_id(model_execute_id)
operator_from_one_ids = model_execute_.start_nodes.split(',')
# 查看此次执行的所有节点的状态
result = dict()
while operator_from_one_ids:
item = operator_from_one_ids.pop(0)
if not (item is None or item == ''):
result[id_operator_dict[item].id] = {
"status": id_operator_dict[item].status,
"log": id_operator_dict[item].run_info
}
operator_from_one_ids.extend(
id_operator_dict[item].child_operator_ids.split(','))
return {
"modelExecuteStatus": model_execute_.status,
"operatorStatus": result
}
def get_status_model_execute_end(project_id, start_operator_ids):
"""
获取运行结束后的状态
:param project_id:
:param start_operator_ids:
:return:
"""
# 获取 model
model = ModelDao.get_model_by_project_id(project_id)
if model is False:
return False
# 获取 operator
operators = OperatorDao.get_operator_by_model_id(model.id)
if operators is False:
return False
# 构造dict
id_operator_dict = {}
for operator in operators:
id_operator_dict[operator.id] = operator
operator_from_one_ids = []
operator_from_one_ids.extend(start_operator_ids)
# 从此次执行 起始节点及以后节点的状态
status_set = set()
while operator_from_one_ids:
item = operator_from_one_ids.pop(0)
if not (item is None or item == ''):
status_set.add(id_operator_dict[item].status)
operator_from_one_ids.extend(
id_operator_dict[item].child_operator_ids.split(','))
if len(status_set) == 1 and "success" in status_set:
return "success"
else:
return "error"
def update_model(project_id, start_nodes, config, relationship, config_order):
"""
更新 model (处理流程图)
ToDo: 没有考虑数据库操作的原子性
:param project_id:
:param start_nodes:
:param config:
:return:
"""
try:
# 获取model
model = ModelDao.get_model_by_project_id(project_id)
if model is False:
return False
# 更新model
update_result = ModelDao.update_with_project_id(
project_id, start_nodes, relationship, config_order)
if update_result is False:
return False
# 获取 operator
operator_old = OperatorDao.get_operator_by_model_id(model.id)
# 新的operator
operators = []
config_dict = json.loads(config)
for operator_id in config_dict.keys():
operator_dict = config_dict.get(operator_id)
operator_style = json.dumps(
{
'location': operator_dict['location'],
}, ensure_ascii=False)
# json.dumps(operates, ensure_ascii=False)
ope = Operator(id=operator_id,
father_operator_ids=','.join(operator_dict['pre']),
child_operator_ids=','.join(operator_dict['next']),
model_id=model.id,
status='initial',
operator_type_id=operator_dict['name'],
operator_config=json.dumps(operator_dict['config'],
ensure_ascii=False),
operator_style=operator_style)
operators.append(ope)
# 准备删除的算子
operator_delete = []
# 准备更新的算子
operator_update = []
for old in operator_old:
flag_exist = False
for new in operators:
if old.id == new.id:
flag_exist = True
operator_update.append([old, new])
break
if not flag_exist:
operator_delete.append(old)
# 删除算子
for delete in operator_delete:
OperatorDao.delete_operator_by_id(delete.id)
print("********删除算子", delete)
# 更新算子
for update in operator_update:
update[0].father_operator_ids = update[1].father_operator_ids
update[0].child_operator_ids = update[1].child_operator_ids
update[0].model_id = update[1].model_id
update[0].operator_type_id = update[1].operator_type_id
update[0].operator_config = update[1].operator_config
update[0].operator_style = update[1].operator_style
# 更新算子
OperatorDao.create_operator([update[0]])
print("*********更新算子", update[0])
# 准备添加的算子
operator_add = []
for new in operators:
flag_exist = False
for old in operator_old:
if old.id == new.id:
flag_exist = True
break
if not flag_exist:
operator_add.append(new)
# 添加算子
OperatorDao.create_operator(operator_add)
print("*********添加算子", operator_add)
return True
except:
traceback.print_exc()
return False
