def __initialize_equips(self, station_dir, station_name):
try:
equips_data = pd.read_csv(os.path.join(station_dir, '设备.csv'), encoding='gbk')
except FileNotFoundError:
return None
# 生成设备节点
for i in range(len(equips_data)):
create_node(self.graph, '设备',
{'name': equips_data['设备类型'][i],
'名称': equips_data['设备名称'][i],
'编码': equips_data['设备编码'][i]},
overwrite=False)
# 建立台站到设备的连接
create_relation(self.graph, '台站', '设备', station_name, equips_data['设备编码'][i], sub_key='编码')
# 建立设备到设备的连接
for equ in str(equips_data['连接设备'][i]).split('、'):
if equ == '' or equ == 'nan':
continue
create_relation(self.graph, '设备', '设备', equips_data['设备编码'][i],
int(equ), main_key='编码', sub_key='编码', newnode=False)
# 建立设备到线路的连接
for route in equips_data['连接路由'][i].split('、'):
create_relation(self.graph, '设备', '线路', equips_data['设备编码'][i], route, main_key='编码')
def __initialize_station(self, station_dir):
try:
station_info = pd.read_csv(os.path.join(station_dir, '台站.csv'), encoding='gbk')
except FileNotFoundError:
return None
# 生成台站节点
create_node(self.graph, '台站',
{'name': station_info['台站名称'][0],
'代号': station_info['台站代号'][0],
'机房面积': station_info['机房面积'][0]})
# 生成路由信息
self.__initialize_routes(station_dir, station_info['台站名称'][0])
self.__initialize_equips(station_dir, station_info['台站名称'][0])
return None
def get_or_create_node(gdb, n, graph, creation_info=False):
created = False
slug_id = defaultfilters.slugify(n['_slug'])[:150]
result = search_in_index(gdb, slug_id, n['_type'], str(graph.id))
if len(result) == 1:
node = result[0]
n['_slug'] = slug_id
for key, value in n.iteritems():
node.set(key, value)
else:
node = create_node(gdb, n, graph)
created = True
return return_function(node, created, creation_info)
def __initialize_routes(self, station_dir, station_name):
'''
该函数用于生成路由连接部分的图谱
:param station_dir: 台站文件夹
:param station_name: 台站名称
:return:
'''
try:
stations_data = pd.read_csv(os.path.join(station_dir, '路由.csv'), encoding='gbk')
except FileNotFoundError:
return None
# 生成路由节点
for i in range(len(stations_data)):
# 建立线路节点
create_node(self.graph, '线路',
{'name': stations_data['线路名称'][i],
'纤芯数量': stations_data['纤芯数量'][i],
'在用纤芯': stations_data['承载系统'][i],
'不可用纤芯': str(stations_data['不可用纤芯'][i]).replace('、', '/')})
# 创建至台站连接
# 本端台站至线路的连接
create_relation(self.graph, '台站', '线路', station_name, stations_data['线路名称'][i])
# 对端台站到线路的连接
create_relation(self.graph, '台站', '线路', stations_data['通达方向'][i], stations_data['线路名称'][i])
# 台站到台站之间的连接
create_relation(self.graph, '台站', '台站', station_name, stations_data['通达方向'][i])
# 建立系统节点
systems = str(stations_data['承载系统'][i]).split('、')
for j in range(len(systems)):
system = systems[j].split('[')[0]
if str(system) == 'nan':
break
create_node(self.graph, '系统', {'name': system})
create_relation(self.graph, '台站', '系统', station_name, system)
create_relation(self.graph, '线路', '系统', stations_data['线路名称'][i], system)
# 建立中继节点
relays = str(stations_data['中继站'][i]).split('、')
for relay in relays:
if relay == 'nan':
break
create_node(self.graph, '中继', {'name': relay})
create_relation(self.graph, '线路', '中继', stations_data['线路名称'][i], relay)
return None
def add_node_ajax(request, graph_id):
graph = GraphDB.objects.get(pk=graph_id)
if not request.user.has_perm('schema.%s_can_add_data' % graph.name):
return unauthorized_user(request)
if request.method == 'GET':
gdb = neo4jclient.GraphDatabase(GRAPHDB_HOST)
tmp_node = simplejson.loads(request.GET['json_node'])
collapse = simplejson.loads(request.GET['collapse'])
node = get_internal_attributes(tmp_node['id'],
tmp_node['type'],
graph_id,
request.user)
if collapse:
new_node = get_or_create_node(gdb, node, graph)
else:
new_node = create_node(gdb, node, graph)
if new_node:
success = True
else:
success = False
return HttpResponse(simplejson.dumps({'success': success}))
def save_form(self, *args, **kwargs):
properties = get_internal_attributes(self.data["_slug"], nodetype.name,
nodetype.graph.id, "", False)
node_properties = nodetype.nodeproperty_set.all().values("key")
keys = [p["key"] for p in node_properties]
for key in keys:
if key in self.data and len(self.data[key]) > 0:
properties[key] = self.data[key]
properties["_slug"] = self.data["_slug"]
properties["_type"] = nodetype.name
properties["_graph"] = unicode(nodetype.graph.id)
node = create_node(gdb, properties, nodetype.graph)
if node:
# Create relationships only if everything was OK with node creation
for relationship in nodetype.get_edges():
rel_name = relationship.relation.name
if rel_name in self.data and len(self.data[rel_name]) > 0:
idx = gdb.relationships.indexes.get('sylva_relationships')
for node_id in self.data.getlist(rel_name):
node_to = gdb.nodes.get(node_id)
if node_to:
rel = node.relationships.create(rel_name,
to=node_to)
slug = "%s:%s:%s" % (rel.start.properties['_slug'],
rel_name,
rel.end.properties['_slug'])
gid = str(nodetype.graph.id)
inner_props = get_internal_attributes(slug,
rel_name,
gid,
"",
True)
for key, value in inner_props.iteritems():
rel.set(key, value)
rel.set('_url', "/".join(rel.url.split('/')[-2:]))
idx['_slug'][slug] = rel
idx['_type'][rel_name] = rel
idx['_graph'][gid] = rel
