def create_node_relationship(node_a, node_b, leg, graph_object): a = Node("Airport", lat=node_a["latitude"], lon=node_a["longitude"], name=node_a["name"], location=node_a["location"], state=node_a["state"], country=node_a["country"], start_date=node_a["start-date"], code=node_a["code"]) a.__primarylabel__ = "name" a.__primarykey__ = "name" b = Node("Airport", lat=node_b["latitude"], lon=node_b["longitude"], name=node_b["name"], location=node_b["location"], state=node_b["state"], country=node_b["country"], start_date=node_b["start-date"], code=node_b["code"]) b.__primarylabel__ = "name" b.__primarykey__ = "name" connection = Relationship.type("CONNECTION") graph_object.merge(connection(a, b, airline=leg))
def new_arp_neighbor_rel(self, Router): arp_neighbor = self.snmp2json[self.NetElement][u'L3Domain'][u'ARP_Neighbors'] for i in arp_neighbor: int_id = i if ('Int_Id:' + int_id) in self.interfaces: int_bw = self.interfaces['Int_Id:' + int_id]['ifSpeed'] int_name = self.interfaces['Int_Id:' + int_id]['ifDescr'] for j in arp_neighbor[i]: if not '127.0.0.' in j: ip_addr = j[0] mac_addr = j[1] neigh_info = j[2] ip = Node('Ip_address', status = 'Active', address = ip_addr) ip.__primarylabel__ = "Ip_address" ip.__primarykey__ = "address" if not self.find_ip_addr(ip_addr): graph.create(ip) query = ''' MATCH (i:Interface)-[:BELONGS_TO]->(r:Router), (ip:Ip_address) WHERE (r.hostname = {hostname} and i.int_id = {int_id}) and ip.address = {ip_addr} CREATE UNIQUE (i)-[:SEEN_BY_ARP]->(ip) ''' rel_arp_int_ip = graph.run(query, hostname = self.hostname, int_id = int_id, ip_addr = ip_addr) if (('0:50:56' or '0:c:29' or '0:25:b3') in mac_addr): server = Node('Server', MAC = mac_addr, property = 'VmWare_VM') server.__primarylabel__ = "Server" server.__primarykey__ = "MAC" CONFIGURED_IN = Relationship.type('CONFIGURED_IN') rel_ip_server = graph.merge(CONFIGURED_IN(ip,server)) elif ('0:9:f:' in mac_addr): firewall = Node('Firewall', MAC = mac_addr, property = 'FortiNet') firewall.__primarylabel__ = 'Firewall' firewall.__primarykey__ = 'MAC' CONFIGURED_IN = Relationship.type('CONFIGURED_IN') rel_ip_server = graph.merge(CONFIGURED_IN(ip,firewall)) self.arp_relationship(Router, firewall, int_name, int_bw) elif (('5c:f3:fc' or '0:15:17') in mac_addr): if re.search('5c:f3:fc', mac_addr): server = Node('Server', MAC = mac_addr, property = 'IBM_SERVER') else: server = Node('Server', MAC = mac_addr, property = 'INTEL_SERVER') server.__primarylabel__ = "Server" server.__primarykey__ = "MAC" CONFIGURED_IN = Relationship.type('CONFIGURED_IN') rel_ip_server = graph.merge(CONFIGURED_IN(ip,server)) elif 'message' not in neigh_info: hostname = neigh_info[u'hostname'] dev_info = neigh_info[u'description'] print (hostname, self.hostname, self.NetElement) arp_router = Node('Router', hostname = hostname, devinfo = dev_info) arp_router.__primarylabel__ = "Router" arp_router.__primarykey__ = "hostname" self.arp_relationship(Router, arp_router, int_name, int_bw, hostname)
def create_data_type_node(type: str, type_val: str) -> Node: print('get_or_create_data_type_node : ', type, type_val) n = None if DataTypeEnum(type) is DataTypeEnum.ANALYTICS: n = Node("Analytics", name=type_val) n.__primarylabel__ = "Analytics" n.__primarykey__ = "name" elif DataTypeEnum(type) is DataTypeEnum.MODEL: n = Node("Model", name=type_val) n.__primarylabel__ = "Model" n.__primarykey__ = "name" return n
def organizations(graph): #Transaction Container - where we store operations before committing to graph register = graph.begin() #Open file and assign to reader fileIn = "organization.csv" in_file = open(fileIn, 'r') reader = csv.reader(in_file, delimiter=',') try: i = 0 j = 0 next(reader) for row in reader: if row: user = strip(row[0]) organization = strip(row[1]) orgType = strip(row[2]) userNode = Node("User", user_id=user) #primary key and label used for merge comparison userNode.__primarylabel__ = "User" userNode.__primarykey__ = "user_id" organizationNode = Node("Organization", name=organization, type=orgType) organizationNode.__primarylabel__ = "Organization" organizationNode.__primarykey__ = "name" WORKS_FOR = Relationship.type("WORKS_FOR") #Merge combines if already exists, else creates new register.merge(WORKS_FOR(userNode, organizationNode)) i += 1 j += 1 if (i == 4): #submits a batch every 4 lines read register.commit() print(j, "organization lines processed") i = 0 register = graph.begin() else: register.commit() #submits remainder of lines read print(j, "organization lines processed") except Exception as e: print(e, row, reader.line_num)
def graph_member(self, member): """Create a graph node for a member in GCP.""" logging.info("Graphing member " + member.name) node = Node("member", type=member.type, name=member.name) node.__primarylabel__ = "member" node.__primarykey__ = "name" for binding in member.sa_scopes: # 1. Parse bindings for the service account user permissions for key in binding.keys(): matcher = NodeMatcher(self.graph) location_node = matcher.match(key, name=binding[key]).first() # 2. Find the Org, project, or resource node at the binding level if location_node is None: logging.warning("No node found for {0} : {1}".format( key, binding[key])) logging.warning("{0} not mapped".format(member.name)) if location_node: # 3. Create relationship with the resource node(s) and the member node relationship = Relationship.type("iam_binding") try: self.graph.merge(relationship(node, location_node)) except ConnectionRefusedError as e: logging.error(str(e)) logging.error( "Unable to connect to the graph service, exiting.") sys.exit()
def _adjust_label_name(self, node: Node) -> str: label_name = list(node.labels)[0] node.clear_labels() if callable(self.config_func_label_name_generator_func): custom_name = self.config_func_label_name_generator_func( label_name) if custom_name is not None: return custom_name label_name_adjusted = label_name if label_name in self.config_dict_json_attr_to_reltype_instead_of_label: label_name_adjusted = self.config_dict_json_attr_to_reltype_instead_of_label[ label_name] if label_name in self.config_dict_label_override: label_name_override_config = self.config_dict_label_override[ label_name] if isinstance(label_name_override_config, str): label_name_adjusted = label_name_override_config elif isinstance(label_name_override_config, dict): label_name_adjusted = list( label_name_override_config.keys())[0] # add extra props as configured by caller extra_props = list(label_name_override_config.values())[0] for extra_prop, extra_val in extra_props.items(): node[extra_prop] = extra_val label_name_adjusted = (label_name_adjusted.capitalize() if self.config_bool_capitalize_labels else label_name_adjusted) node.add_label(label_name_adjusted) node.__primarylabel__ = label_name_adjusted return node
def create_data_node(data_node: DataNode): print('GraphService: create_data_node: data_node = ', data_node.type) n_data = Node('Data', url_prefix=data_node.url_prefix, endpoint=data_node.endpoint, description=data_node.description, header=data_node.header) n_data.__primarylabel__ = "Data" n_data.__primarykey__ = "endpoint" tx = graph.begin() tx.merge(n_data) if data_node.source is not None: n_source = GraphService.create_source_node(data_node.source) r_data_source = Relationship(n_data, 'SOURCE', n_source, name=data_node.source) tx.merge(r_data_source) if data_node.type is not None: n_type = GraphService.create_data_type_node( data_node.type, data_node.type_val) r_data_type = Relationship(n_data, 'DATA_TYPE', n_type) tx.merge(r_data_type) tx.commit()
def update_event(events, key): event = NodeObject("Event") event.name = key event.full_name = events.get("full_name") print(event.full_name) event.image = events.get("image") event.object_id = events.get("object_id") event.weight = events.get("weight") type1 = events.get("type") event.location = events.get("location") event.keywords = events.get("keywords") # print(event.keywords) graph = neo4j_connect() graph.nodes.match("Event") graph.merge(event) graph.push(event) graph.run( "MATCH(n:Event)-[r]->(p:Event_Category) detach delete r, p return p") if type1 not in ('', None): transaction = graph.begin() event_type = Node("event_category", name=type1) event_type.__primarylabel__ = "Event_Category" event_type.__primarykey__ = type1 transaction.create(event_type) rels_event = Relationship(event.__node__, "BELONG TYPE OF EVENT", event_type) transaction.create(rels_event) transaction.commit() transaction.finished() return event.__node__
def new_interfaces_node(self, router): self.interfaces = self.snmp2json[self.NetElement][u'Interfaces'] for i in self.interfaces: int_id = i.replace('Int_Id:', '') for j in self.interfaces[i]: if j == 'ifPhysAddress': if_mac_address = self.interfaces[i][j] if_uniqueness = if_mac_address + '_' + self.hostname + '_' + int_id elif j == 'ifDescr': if_name = self.interfaces[i][j] elif j == 'ifOperStatus': if_op_status = self.interfaces[i][j] elif j == 'ifAdminStatus': if_adm_status = self.interfaces[i][j] elif j == 'ifSpeed': if_speed = self.interfaces[i][j] elif j == 'ifMtu': if_mtu = self.interfaces[i][j] interface = Node('Interface', name = if_name, int_id = int_id, MAC = if_mac_address, UNIQUENESS= if_uniqueness, AdmStatus = if_adm_status, OpStatus = if_op_status, Speed = if_speed, MTU = if_mtu) interface.__primarylabel__ = "Interface" interface.__primarykey__ = "UNIQUENESS" BELONGS_TO = Relationship.type('BELONGS_TO') rel_router_int = graph.merge(BELONGS_TO(interface,router)) self.new_ip_addr_node()
def test_can_merge_node_with_primary_label_and_key(graph): graph.delete_all() a = Node("Person", name="Alice") a.__primarylabel__ = "Person" a.__primarykey__ = "name" graph.merge(a) assert graph.nodes.match("Person", name="Alice").first() == a
def importMondeDiploFiles(path_to_medias_francais, path_to_relations_medias_francais): ''' import or mondediplo files in Neo4j database as "Entity" nodes and "ONED_BY" relationships. Create all properties as Diplo_propname. No relationship cretaed to other nodes ''' medias_df = pd.read_csv(path_to_medias_francais, sep=' ') # nodes i = 0 totnbnodes = len(medias_df) - 1 print(totnbnodes, "nodes found in file") for index, row in medias_df.iterrows(): i = 1 + 1 nodematch = graph.nodes.match(entity_name=row["nom"]).first() if nodematch == None: try: nodematch = Node('Entity', entity_name=row["nom"]) nodematch.__primarylabel__ = 'Entity' nodematch.__primarykey__ = 'entity_name' graph.merge(nodematch) except: print("could not import ", row["nom"]) nodematch = None if nodematch != None: for key in row.keys(): nodematch["Diplo_" + key] = row[key] graph.push(nodematch) if i % 100 == 0: print(".", end=" ") if i % 1000 == 0: print(i, "/", totnbnodes) print(len(graph.nodes.match("Entity")), "Entities in db after import") # links relations_df = pd.read_csv(path_to_relations_medias_francais, sep=' ') totnblinks = len(relations_df) - 1 print(totnblinks, "links found in file") j = 0 for index, row in relations_df.iterrows(): j = j + 1 results = db.run( "MATCH (n1:Entity) WHERE n1.Diplo_nom = $origine " "MATCH (n2:Entity) WHERE n2.Diplo_nom = $cible " "MERGE (n2)-[:OWNED_BY {valeur:$v, source:$s, datePubli:$dp, dateConsult:$dc}] ->(n1) ", { "origine": row['origine'], "cible": row['cible'], "v": row['valeur'], "s": row['source'], "dp": row['datePublication'], "dc": row['dateConsultation'] }) if j % 100 == 0: print(".", end=" ") if j % 1000 == 0: print(j, "/", totnblinks) relfin = len(graph.relationships.match((), "OWNED_BY")) print( relfin, " OWNED_BY relationships in db after import (or not : there's a bug)")
def gregorian_calendar(graph, time1=None, node1=None): if time1 is None: time1 = datetime.now() # gregorian calendar node gregorian_node = Node("Calendar", calendar_type="Gregorian") gregorian_node.__primarylabel__ = list(gregorian_node.labels)[0] gregorian_node.__primarykey__ = "calendar_type" graph.merge(gregorian_node) # year node that_year_node = Node("Year", year=time1.year, key=time1.strftime("%Y")) that_year_node.__primarylabel__ = list(that_year_node.labels)[0] that_year_node.__primarykey__ = "year" graph.merge(that_year_node) # calendar has year rel = Relationship(gregorian_node, "YEAR", that_year_node) graph.merge(rel) # month node that_month_node = Node("Month", month=time1.month, key=time1.strftime("%m-%Y")) that_month_node.__primarylabel__ = list(that_month_node.labels)[0] that_month_node.__primarykey__ = "month" graph.merge(that_month_node) # year has month rel = Relationship(that_year_node, "MONTH", that_month_node) graph.merge(rel) # day node that_day_node = Node("Day", day=time1.day, key=time1.strftime("%d-%m-%Y")) that_day_node.__primarylabel__ = list(that_day_node.labels)[0] that_day_node.__primarykey__ = "day" graph.merge(that_day_node) # month has day rel = Relationship(that_month_node, "DAY", that_day_node) graph.merge(rel) # post was published on (gregorian) day if node1 is not None: rel = Relationship(node1, "ON", that_day_node) graph.create(rel)
def interests(graph): #Transaction Container - where we store operations before committing to graph register = graph.begin() #Open file and assign to reader fileIn = "interest.csv" in_file = open(fileIn, 'r') reader = csv.reader(in_file, delimiter=',') try: i = 0 j = 0 next(reader) for row in reader: if row: user = strip(row[0]) interest = strip(row[1]) interestLevel = strip(row[2]) userNode = Node("User", user_id=user) #primary key and label used for merge comparison userNode.__primarylabel__ = "User" userNode.__primarykey__ = "user_id" interestNode = Node("Interest", name=interest) interestNode.__primarylabel__ = "Interest" interestNode.__primarykey__ = "name" INTERESTED_IN = Relationship.type("INTERESTED_IN") #Merge combines if already exists, else creates new register.merge( INTERESTED_IN(userNode, interestNode, weight=interestLevel)) i += 1 j += 1 if (i == 4): #submits a batch every 4 lines read register.commit() print(j, "interest lines processed") i = 0 register = graph.begin() else: register.commit() #submits remainder of lines read print(j, "interest lines processed") except Exception as e: print(e, row, reader.line_num)
def create_node(self, prov_object): node_data = prov_object.to_dict() label = node_data.pop('label') node = Node(label, **node_data) node.__primarylabel__ = label node.__primarykey__ = 'id' self.graph.merge(node) logger.debug("Created node: {}".format(node))
def create_URL_node(self, url) -> Node: url_node = Node('URL', url=url['url'], expanded_url=url['expanded_url'], display_url=url['display_url']) url_node.__primarykey__ = 'url' url_node.__primarylabel__ = 'URL' return url_node
def update_node(node): if node.get("labels") in ('', None) or node.get("name") in ('', None): return None, 201 node_find = find_node(node.get("labels"), node.get("name")) print(node_find) # print(node_find) if node_find not in ('', None): nodes = NodeObject(node.get("labels")) nodes.name = node.get("name") nodes.full_name = node.get("full_name") # if full_name == '': # full_name = '' nodes.image = node.get("image") # if image == '': # image = '' nodes.object_id = node.get("object_id") # if object_id == 0: # object_id = '' nodes.weight = node.get("weight") # if weight == 0: # weight = '' nodes.keywords = node.get("keywords") # if keywords == '': # keywords = '' type1 = node.get("type") nodes.date_time = node.get("date_time") # if date_time == '': # date_time = '' # node_temp = Node(labels, name=name, full_name=full_name, image=image, object_id=object_id, # weight=weight, keywords=keywords, date_time=date_time) # node_temp.__primarylabel__ = labels # node_temp.__primarykey__ = name graph = neo4j_connect() transaction = graph.begin() # transaction.merge(node_temp, labels, "name", name) graph.merge(nodes) graph.push(nodes) graph.run( "MATCH(n:event)-[r]->(p:event_category) detach delete r, p return p" ) if type1 not in ('', None): event_type = Node("event_category", name=type1) event_type.__primarylabel__ = "event_category" event_type.__primarykey__ = type1 transaction.create(event_type) rels_event = Relationship(nodes.__node__, "Belong to the type of event", event_type) transaction.create(rels_event) transaction.commit() transaction.finished() cypher = """MATCH path = (n:`{labels}`)-[]-() where n.name = '{name}' """.format( labels=nodes.__primarylabel__, name=nodes.name) result = export_json_run_cypher(cypher) return result
def graph_organization(self, org): """Create a graph node for a GCP organization.""" logging.info("Graphing organization " + org.name) org_node = Node("organization", name=org.name, id=org.id) org_node.__primarylabel__ = "organization" org_node.__primarykey__ = "name" for folder in org.get_folders(): self.graph_folder(folder, org_node) for project in org.get_projects(): self.graph_project(project, org_node)
def set_people_and_university_relationship(self, people, university): if isinstance(people, str): people = json.loads(people) people_node = Node("Pessoa", Nome=people['nome'], DataDeNascimento=people['data_nascimento'], Email=people['email'], Cidade=people['cidade'], Estado=people['estado'], Cargo=people['cargo']) people_node.__primarylabel__ = "Pessoa" people_node.__primarykey__ = "Nome" if isinstance(university, str): university = json.loads(university) university_node = Node("Universidade", Nome=university['nome'], Cidade=university['cidade'], Estado=university['estado']) university_node.__primarylabel__ = "Universidade" university_node.__primarykey__ = "Nome" relationship = Relationship.type("ESTUDA") self._graph.merge(relationship(people_node, university_node))
def _create_collection_hub_node(self, member_label_name, hub_id): hub_node_label = self._get_hub_node_label_name(member_label_name) hub_node = Node(hub_node_label, id=hub_id) hub_node._is_collectionhub = True hub_node.__primarylabel__ = hub_node_label hub_node.__primarykey__ = "id" for lbl in self.config_list_collection_anchor_extra_labels: hub_node.add_label(lbl) if self.config_str_collection_anchor_attach_list_members_label: hub_node.add_label(member_label_name) return hub_node
def dynamic_neighbors(self, router): ospf_info = self.snmp2json[self.NetElement][u'L3Domain'][u'OSPF_INFO'] bgp_info = self.snmp2json[self.NetElement][u'L3Domain'][u'BGP_INFO'] if ospf_info['Router_Id']: router['Router_Id'] = ospf_info['Router_Id'] graph.push(router) ospf_areas = ospf_info['Areas'] ospf_neigh = ospf_info['Neighbors'] for area in ospf_areas: area_id = ospf_areas[area]['AreaId'] area_status = ospf_areas[area]['AreaStatus'] area_auth_type = ospf_areas[area]['AuthType'] ospf_area_node = Node('Ospf_Area', id = area_id, status = area_status, auth = area_auth_type) ospf_area_node.__primarylabel__ = 'Ospf_Area' ospf_area_node.__primarykey__ = 'id' PART_OF = Relationship.type('PART_OF') rel_router_int = graph.merge(PART_OF(router,ospf_area_node)) for neighbor in ospf_neigh: neigh_id = ospf_neigh[neighbor]['NbrRtrId'] neigh_ip = ospf_neigh[neighbor]['NbrIpAddr'] neigh_state = ospf_neigh[neighbor]['NbrState'] ip = Node('Ip_address', status = 'Active', address = neigh_ip) ip.__primarylabel__ = "Ip_address" ip.__primarykey__ = "address" OSPF_NEIGHBOR = Relationship.type('OSPF_NEIGHBOR') rel_ospf_router = graph.merge(OSPF_NEIGHBOR(router,ip, state = neigh_state, neigh_rt_id = neigh_id)) if bgp_info['LocalAs']: router['LocalAs'] = bgp_info['LocalAs'] graph.push(router) bgp_peers = bgp_info['Peers'] for peer in bgp_peers: peer_local_add = bgp_peers[peer]['PeerLocalAddr'] peer_id = bgp_peers[peer]['PeerIdentifier'] peer_as = bgp_peers[peer]['PeerRemoteAs'] peer_address = bgp_peers[peer]['PeerRemoteAddr'] peer_state = bgp_peers[peer]['PeerState'] ip = Node('Ip_address', status = 'Active', address = peer_address) ip.__primarylabel__ = "Ip_address" ip.__primarykey__ = "address" BGP_PEER = Relationship.type('BGP_PEER') rel_bgp_router = graph.merge(BGP_PEER(router, ip, state = peer_state, peer_rt_id = peer_id))
def set_people_and_company_relationship(self, people, company): if isinstance(people, str): people = json.loads(people) people_node = Node("Pessoa", Nome=people['nome'], DataDeNascimento=people['data_nascimento'], Email=people['email'], Cidade=people['cidade'], Estado=people['estado'], Cargo=people['cargo']) people_node.__primarylabel__ = "Pessoa" people_node.__primarykey__ = "Nome" if isinstance(company, str): company = json.loads(company) company_node = Node("Empresa", Nome=company['nome'], Cidade=company['cidade'], Estado=company['estado'], Area=company['area']) company_node.__primarylabel__ = "Empresa" company_node.__primarykey__ = "Nome" relationship = Relationship.type("TRABALHA") self._graph.merge(relationship(people_node, company_node))
def test_merge_with_primary_key_list(self): a = Node("A", a=1) b = Node("B", b=2) self.graph.create(a | b) a_id = remote(a)._id b_id = remote(b)._id node = Node("A", "B", a=1, b=2) node.__primarylabel__ = "B" node.__primarykey__ = ["b"] self.graph.merge(node, "A", "a") assert remote(node)._id != a_id assert remote(node)._id == b_id
def test_merge_with_magic_values_overrides_arguments(self): a = Node("A", a=1) b = Node("B", b=2) self.graph.create(a | b) a_id = remote(a)._id b_id = remote(b)._id node = Node("A", "B", a=1, b=2) node.__primarylabel__ = "B" node.__primarykey__ = "b" self.graph.merge(node, "A", "a") assert remote(node)._id != a_id assert remote(node)._id == b_id
def create_event(events): # print(object) # event = NodeObject("event") name = events.get('name') full_name = events.get("full_name") image = events.get("image") object_id = events.get("object_id") weight = events.get("weight") type1 = events.get("type") location = events.get("location") date_time = events.get("date_time") keywords = events.get("keywords") graph = neo4j_connect() event_find = graph.nodes.match("Event", name=name).first() if event_find not in ('', None): return ("Event da ton tai") pattern = """ Create(m:Event{{name:'{name}', full_name:'{full_name}', image:'{image}', object_id:{object_id}, weight:{weight}, location:'{location}', date_time: datetime("{date_time}"), keywords:'{keywords}'}}) return m""" pattern = pattern.format(name=name, full_name=full_name, image=image, object_id=object_id, weight=weight, location=location, date_time=date_time, keywords=keywords) print(pattern) graph.run(pattern) event = graph.nodes.match("Event", name=name).first() print(event) transaction = graph.begin() if type1 not in ('', None): event_type = Node("Event_Category", name=type1) event_type.__primarylabel__ = "Event_Category" event_type.__primarykey__ = type transaction.create(event_type) rels_event = Relationship(event, "BELONG TYPE OF EVENT", event_type) transaction.create(rels_event) #Create rels event category object = events.get("object") if len(object) not in ('', None): for x in object.split(","): if x not in ('', None): object_find = graph.nodes.match(name=x.strip()).first() transaction.create( Relationship(object_find, events.get("object_rels"), event)) transaction.commit() transaction.finished() return event
def get_character(message): if message['AuctionType'] == 'request': char_id = message['BuyerCharacterId'] char_name = message['BuyerName'] elif message['AuctionType'] == 'offer': char_id = message['SellerCharacterId'] char_name = message['SellerName'] char_node = Node('Character', Id=char_id, Name=char_name) char_node.__primarylabel__ = 'Character' char_node.__primarykey__ = 'Id' return char_node
def test_merge_with_magic_values_overrides_arguments(graph, make_unique_id): label_a = make_unique_id() label_b = make_unique_id() a = Node(label_a, a=1) b = Node(label_b, b=2) graph.create(a | b) a_id = a.identity b_id = b.identity node = Node(label_a, label_b, a=1, b=2) node.__primarylabel__ = label_b node.__primarykey__ = "b" graph.merge(node, label_a, "a") assert node.identity != a_id assert node.identity == b_id
def graph_service_account(self, service_account, parent_node): """Create a graph node for a service account.""" node = Node("service_account", name=service_account.email, id=service_account.id) node.__primarylabel__ = "service_account" node.__primarykey__ = "name" relationship = Relationship.type("sa_child_of") try: self.graph.merge(relationship(node, parent_node)) except ConnectionRefusedError as e: logging.error(str(e)) logging.error("Unable to connect to the graph service, exiting.") sys.exit()
def test_can_merge_node_with_primary_label_overriding_model(graph): from py2neo.ogm import Model class Person(Model): __primarylabel__ = "Human" __primarykey__ = "name" graph.delete_all() a = Node("Person", name="Alice") a.__model__ = Person a.__primarylabel__ = "Person" graph.merge(a) assert graph.nodes.match("Person", name="Alice").first() == a
def new_ip_addr_node(self): ip_addresses = self.snmp2json[self.NetElement][u'L3Domain'][u'IPs'] for i in ip_addresses: int_id = i for j in ip_addresses[i]: if not '127.0.0.' in j: if not self.find_ip_addr(j): ip = Node('Ip_address',int_id = int_id, status = 'Active', address = j) ip.__primarylabel__ = "Ip_address" ip.__primarykey__ = "address" graph.create(ip) query = '''MATCH (i:Interface)-[:BELONGS_TO]->(r:Router), (ip:Ip_address) WHERE ((r.hostname = {hostname} and i.int_id = {int_id}) and ip.address = {address}) CREATE UNIQUE (ip)-[:CONFIGURED_IN]->(i) ''' rel_ip_int = graph.run(query, hostname = self.hostname, int_id = int_id, address = j )
def create_vis_node(vis_node: VisNode): print('GraphService: create_vis_node: vis_node = ', vis_node) n_vis = Node('Vis', name=vis_node.name, description=vis_node.description) n_vis.__primarylabel__ = "Vis" n_vis.__primarykey__ = "name" tx = graph.begin() n_vis_type = GraphService.create_vis_type_node(vis_node.vis_type) r_vis_vis_type = Relationship(n_vis, 'VIS_TYPE', n_vis_type) tx.merge(r_vis_vis_type) tx.commit()
def get_character(message): if message['AuctionType'] == 'request': char_id = message['BuyerCharacterId'] char_name = message['BuyerName'] elif message['AuctionType'] == 'offer': char_id = message['SellerCharacterId'] char_name = message['SellerName'] char_node = Node( 'Character', Id = char_id, Name = char_name ) char_node.__primarylabel__ = 'Character' char_node.__primarykey__ = 'Id' return char_node
def get_item(message): group = message['ItemGroupTypeId'] enchantment = message['EnchantmentLevel'] quality = message['QualityLevel'] item_id = f"{group}@{enchantment}&{quality}" item_node = Node( 'Item', Id = item_id, Group = message['ItemGroupTypeId'], Tier = message['Tier'], Enchantment = enchantment, Quality = quality ) item_node.__primarylabel__ = "Item" item_node.__primarykey__ = 'Id' return item_node