def to_update_oneevent():
name = request.json['事件名称']
graph.run("match(a:%s) match (a)-[b]-() delete b delete a" % ("S" + name))
time = request.json['时间']
plane = request.json['客机型号']
airline = request.json['航空公司']
flightnum = request.json['航班号']
beginPlace = request.json['起飞地点']
landPlace = request.json['降落地点']
incidentPalce = request.json['出事地点']
evenType = request.json['事件类型']
airlineType = request.json['航线类型']
flightType = request.json['航班类型']
weather = request.json['天气情况']
stage = request.json['操作阶段']
reason = request.json['原因']
result = request.json['结果']
injured = request.json['人员伤亡']
grade = request.json['等级']
addevent(name, time, plane, airline, flightnum, beginPlace, landPlace,
incidentPalce, evenType, airlineType, flightType, weather, stage,
reason, result, injured, grade)
return_result = {}
return_result['success'] = True
return jsonify(return_result)
def relations_data_process(node, relations):
p1_id = node['properties']['ID']
for relation in relations:
rel_type = relation['relation']['relation']
rel_props = dict2str(relation['relation'])
p2_id = relation['node']['ID']
graph.run(merge_relation(p1_id, rel_type, rel_props, p2_id))
def item_process(item):
p1_labels = get_p1l(item)
p1_props = get_p1p(item)
r_type = get_rt(item)
r_props = get_rp(item)
p2_labels = get_p2l(item)
p2_props = get_p2p(item)
graph.run(create_cypher(p1_labels, p1_props, r_type, r_props, p2_labels, p2_props))
def delete(task_id):
task = Task.find_one(task_id)
if task.get("message") == "Task not found!":
return {"message": f"Task {task_id} not found!"}
graph.run(f"MATCH (task:Task) WHERE ID(task)={task_id} DETACH DELETE task").evaluate()
return {"message": f"The Task with id {task_id} has been deleted"}
def to_delete_attr():
name = str(request.json['name'])
key = str(request.json['key'])
sql = "match (a:%s) match (a)-[r:属性{name:'%s'}]->(b) delete r" % (name,
key)
graph.run(sql)
return_result = {}
return_result['success'] = True
return jsonify(return_result)
def delete(note_id):
note = Note.find_one(note_id)
if note.get("message") == "Note not found!":
return {"message": f"Note {note_id} not found!"}
graph.run(
f"MATCH (note:Note) WHERE ID(note)={note_id} DETACH DELETE note"
).evaluate()
return {"message": f"The Note with id {note_id} has been deleted"}
def get_pattern_bottom():
result = []
find_names = graph.run("match (a:模式) where a.grade=2 return a.name")
for data in find_names:
s = str(data['a.name'])
find_child = graph.run("match (a:模式) where a.name='" + s +
"' match (a)-[r]->(b) where exists(b.name) return a.name limit 1")
for detail in find_child:
result.append(detail['a.name'])
result = list(set(result))
return result
def get_all_detail(): # 返回所有事件名称、航空公司、操作阶段等
key = request.args['key']
if (key == "事件名称"):
find_details = graph.run(
"match (a:事件名称) match (a)-[:包含]->(b) return b.name")
result = [('S' + item['b.name']) for item in find_details]
else:
find_details = graph.run(
"match (a:模式{name:'%s'}) match (a)-[:包含]->(b) return b.name" % key)
result = [item['b.name'] for item in find_details]
result = list(set(result))
return jsonify(result)
def delete(project_id):
project = Project.find_one(project_id)
if project.get("message") == "Project not found!":
return {"message": f"Project {project_id} not found!"}
graph.run(
f"MATCH (project:Project) WHERE ID(project)={project_id} DETACH DELETE project"
).evaluate()
return {
"message": f"The Project with id {project_id} has been deleted"
}
def get_events_intro(): # 返回指定属性的事件简介信息
key = request.args['key']
value = request.args['value']
events = []
page = request.args['page']
PER_PAGE = 15
if key == '事件名称':
events.append(value)
elif key == '原因' or key == '结果':
find_str = "match (a:模式{name:'" + key + "'}) match (b) where b.name=~'.*" + \
value + ".*' match(a)-[:包含]->(b) return b.name"
dnode = graph.run(find_str)
event_add = []
for data in dnode:
event_add.append(data['b.name'])
for add in event_add:
rnode = graph.run("match (a) where a.name='" + add +
"' match(a)<-[:属性]-(b) return b.name") # 反向查询事件
for data in rnode:
events.append("S" + data['b.name']) # 事件名称
else:
find_node = graph.run(
"match (c:模式{name:'" + key +
"'}) match(c)-[:包含]->(a) match (a) where a.name='" + value +
"' match (a)<-[:属性]-(b) return b.name")
for data in find_node:
events.append("S" + data['b.name'])
events = list(set(events)) # 去重
num = len(events)
page_num = math.ceil(num / PER_PAGE)
startnum = (int(page) - 1) * PER_PAGE
events_info = []
events = events[startnum:startnum + PER_PAGE]
for event in events:
one_info = {}
one_info['事件名称'] = event
matcher_event = NodeMatcher(graph)
find_event = matcher_event.match(event).first()
if find_event != None:
to_search_attributes = ['时间', '出事地点', '航班号', '客机型号', '航空公司']
for attr in to_search_attributes:
eventinfo = graph.run(
'match (a:%s) match (a)-[:属性{name:"%s"}]->(b) return b.name'
% (event, attr))
for data in eventinfo:
one_info[attr] = str(data['b.name'])
events_info.append(one_info)
events_info = sorted(events_info,
key=lambda keys: (keys['时间']),
reverse=False)
events_info.append({'page_num': page_num})
return jsonify(events_info)
def add(current_user_id, task_id, data):
all_attributes = ["client", "date", "message", "user"]
date_created = str(datetime.datetime.now()).replace(' ', 'T') + "Z"
try:
new_note = Node("Note",
client=data['client'],
date=data['date'],
message=data['message'])
except KeyError as e:
return {"message": f"You are missing a key element: {e}"}
new_note['date_created'] = date_created
new_note['user'] = current_user_id
graph.create(new_note)
task = graph.run(
f"MATCH (task:Task) WHERE ID(task)={task_id} RETURN task"
).evaluate()
note_task_rel = Relationship(new_note, 'IS_NOTE_OF', task)
graph.create(note_task_rel)
new_note['id'] = remote(new_note)._id
return new_note
def find_one(user_id):
user = graph.run(f"MATCH (user:Person) WHERE ID(user)={user_id} RETURN user").evaluate()
if user:
user['id'] = user_id
return user
else:
return {"message": "User not found!"}
def get_event_info(): # 根据事件名称返回事件所有属性
event_name = request.args['event_name']
find_event = graph.run('match (b:' + event_name + ') return b.name')
for data in find_event:
node = data['b.name']
node = str(node)
event = 'S' + node
one_info = {}
one_info['事件名称'] = event
to_search_attributes = get_pattern_bottom()
for attr in to_search_attributes:
eventinfo = graph.run(
'match (a:%s) match (a)-[:属性{name:"%s"}]->(b) return b.name' %
(event, attr))
for data in eventinfo:
one_info[attr] = str(data['b.name'])
return jsonify(one_info)
def find_all_by_per(e1):
cypher = graph.run(
'match(p:person{person:"%s"}) return p.chinesename1,p.status,p.achievement'
% (e1))
res = (cypher).data()
for item in res:
print('中文名:' + item['p.chinesename1'] + ' ' + '社会地位:' +
item['p.status'] + ' ' + '主要成就:' + item['p.achievement'])
def find_one(task_id):
task = graph.run(f"MATCH (task:Task) WHERE ID(task)={task_id} RETURN task").evaluate()
if task:
task['id'] = task_id
return task
else:
return {"message": "Task not found!"}
def find_rep_by_per(e1):
cypher = graph.run(
'match(p:person{person:"%s"})-[r:publish]-(c) return c.report' % (e1))
res = (cypher).data()
my_set = set()
for item in res:
my_set.add(item['c.report'])
print(list(my_set))
def get_node_cal_id(node_name):
node = graph.run("""MATCH (n)
WHERE n.Name='{0}'
RETURN labels(n) AS labels, n AS properties""".format(node_name))
data = node.next()
dt = {'labels': data['labels'], 'properties': data['properties']}
dt_hash = my_hash(dt)
dt['properties']['ID'] = dt_hash
return dt
def get_node_relation_with_id(node_name):
relations = graph.run("""MATCH (n)-[r]->(m)
WHERE n.Name='{0}'
RETURN r,m.Name,m.ID""".format(node_name))
rel = []
for relation in relations:
rel_data = {'relation': relation['r'], 'node': {'Name': relation['m.Name'], 'ID': relation['m.ID']}}
rel.append(rel_data)
return rel
def find_per_by_col(e1):
cypher = graph.run(
'match(p)-[r:graduate_from]-(c:college{chinesename:"%s"}) return p.person'
% (e1))
res = (cypher).data()
my_set = set()
for item in res:
my_set.add(item['p.person'])
print(list(my_set))
def find_one(project_id):
project = graph.run(
f"MATCH (project:Project) WHERE ID(project)={project_id} RETURN project"
).evaluate()
if project:
project['id'] = project_id
return project
else:
return {"message": "Project not found!"}
def get_pattern_details(): # 返回模式图下的具体数据节点
name = request.args['name']
limit = request.args['limit']
details = []
finddetail = graph.run("match (a:模式{name:'" + name +
"'}) match (a)-[:`包含`]->(b) return b.name limit " +
limit)
for detail in finddetail:
details.append(detail['b.name'])
return jsonify(details)
def find_one(note_id):
note = graph.run(
f"MATCH (note:Note) WHERE ID(note)={note_id} RETURN note"
).evaluate()
if note:
note['id'] = note_id
return note
else:
return {"message": "Note not found!"}
def find_all():
users = graph.run("MATCH (user:Person) RETURN user").data()
users_list = []
for u in users:
user = u['user']
user_id = remote(user)._id
user['id'] = user_id
users_list.append(user)
return users_list
def realtion_process(line):
datas = re.split(r";", line.strip())
relation = datas[0]
rel_property = relation_property_process(datas[1:-1])
rel_data = re.split(r",", relation.strip())
p1 = rel_data[0].strip()
p2 = rel_data[1].strip()
rel = rel_data[2].strip()
graph.run(merge_person_node(p1))
graph.run(merge_person_node(p2))
if not is_exist_relation(p1, p2, rel):
graph.run(create_relation(p1, p2, rel))
for key in rel_property.keys():
graph.run(set_relation_property(p1, p2, rel, key, rel_property[key]))
def get_reason_participle(): # 返回原因的分词
result = {}
findreason = graph.run(
"match (a:模式{name:'原因'}) match (a)-[:包含]->(b) return b.name")
for data in findreason:
seg_list = jieba.cut(str(data['b.name']), cut_all=False)
for detail in seg_list:
if result.get(detail, -1) == -1:
result[detail] = 1
else:
result[detail] += 1
result = sorted(result.items(), key=lambda x: x[1], reverse=False)
return jsonify(result)
def verify_admin():
username = request.json["username"]
password = request.json["password"]
find_name = matcher.match(username, name=username).first()
if find_name == None:
return jsonify({"success": False})
find_pwd = graph.run("match (a) where a.name='%s' return a.password" %
username)
for item in find_pwd:
pwd = item['a.password']
if pwd == password:
session["is_admin"] = True
return jsonify({"success": True})
return jsonify({"success": False})
def find_all(task_id):
notes = graph.run(
f"MATCH (note:Note)-[:IS_NOTE_OF]->(task:Task) WHERE ID(task)={task_id} RETURN note"
).data()
notes_list = []
for n in notes:
note = n['note']
note_id = remote(note)._id
note['id'] = note_id
notes_list.append(note)
return notes_list
def get_all_events_intro(): # 返回page页事件的简介信息
PER_PAGE = 15 # 每页中包含的事件个数。常量名约定为全大写
page = int(request.args['page'])
data = graph.run(
'match (a:事件名称) match (a)-[:`包含`]->(b) return b.sortflag order by b.sortflag desc'
)
strdata = [str(i['b.sortflag']) for i in data]
page_num = math.ceil(len(strdata) / PER_PAGE)
startnum = (page - 1) * PER_PAGE
index = 0
if startnum == 0:
index = 16
else:
index = 15
newstr = strdata[startnum:(startnum + index)]
events = []
for name in newstr:
one_info = {}
flag = str(name)
names = [
"S" + i['a.name']
for i in graph.run("match (a) where a.sortflag ='" + flag +
"' return a.name")
]
names = list(set(names))
to_search_attributes = ['时间', '出事地点', '航班号', '客机型号', '航空公司']
for its in names:
one_info['事件名称'] = its
for attr in to_search_attributes:
event = graph.run(
'match (a:%s) match (a)-[:属性{name:"%s"}]->(b) return b.name'
% (its, attr))
for data in event:
one_info[attr] = str(data['b.name'])
events.append(one_info)
events.append({'page_num': page_num})
return jsonify(events) # 使用 flask 自带的 json 打包函数
def get_patt_node(): # 返回模式结点和边（source:link:target）
patt_nodes = {}
nodes = []
pat_nodes = graph.run('match (a:模式) return a.name,a.grade')
for data in pat_nodes:
node = {}
node['id'] = data['a.name']
node['grade'] = data['a.grade']
nodes.append(node)
patt_nodes['nodes'] = nodes
link = []
t_rank = []
rank = graph.run('match (a:模式) where exists(a.grade) return a.grade')
for data in rank:
t_rank.append(data['a.grade'])
max_rank = max(t_rank)
# print(max_rank)
for i in range(0, max_rank):
min_node = graph.run('match (a) where a.grade=' + str(i) +
' return a.name')
for data_min in min_node:
max_nodes = []
max_node = graph.run(
'match (a:模式{name:"' + data_min['a.name'] +
'"}) match (a)-[:`包含`]->(b) where exists(b.grade) return b.name'
)
for data_max in max_node:
max_nodes.append(data_max['b.name'])
for maxnode in max_nodes:
links = {}
links['source'] = data_min['a.name']
links['target'] = maxnode
links['linkText'] = '包含'
link.append(links)
patt_nodes['links'] = link
return jsonify(patt_nodes)
def find_all(project_id):
tasks = graph.run(
f"MATCH (task:Task)-[:IS_TASK_OF]->(project:Project) WHERE ID(project)={project_id} RETURN task").data()
tasks_list = []
for t in tasks:
task = t['task']
task_id = remote(task)._id
task['id'] = task_id
users = Task.find_users(task, "IS_USER")
task['users'] = users
tasks_list.append(task)
return tasks_list
