class Neo4jClient(object):
def __init__(self,
user='******',
password='******',
host='localhost',
port=7687):
# self.db = Database("bolt://camelot.example.com:7687")
self.graph = Graph(bolt=True,
host=host,
bolt_port=port,
user=user,
password=password)
self.selector = NodeSelector(self.graph)
def get_graph(self, cypher):
data = self.graph.data(cypher)
return list(data)
def get_data_frame(self, cypher):
data = self.graph.data(cypher)
return DataFrame(data)
def select(self, labels, props):
data = self.selector.select(labels, props)
return list(data)
def select_where(self, label, constraint):
selected = self.selector.select(label).where(constraint)
return list(selected)
def cypher_execute(self, cypher):
result = self.graph.cypher.execute(cypher)
return result
def create_elb():
elbs = loadbalancer.describe_load_balancers()['LoadBalancerDescriptions']
for elb in elbs:
tx = graph.begin()
graphElb = Node("ELB", name=elb['LoadBalancerName'])
tx.merge(graphElb)
tx.commit()
for subnet in elb['Subnets']:
tx = graph.begin()
selector = NodeSelector(graph)
graphSubnet = selector.select("Subnet", subnetId=subnet).first()
rel = Relationship(graphElb, "BELONGS", graphSubnet)
tx.create(rel)
tx.commit()
for instance in elb["Instances"]:
try:
tx = graph.begin()
selector = NodeSelector(graph)
graphInstance = selector.select(
"EC2", instanceId=instance['InstanceId']).first()
rel = Relationship(graphInstance, "BELONGS", graphElb)
tx.create(rel)
tx.commit()
except:
pass
def store_in_neo4j(triple):
from py2neo import Graph, Node, Relationship ,NodeSelector
graph = Graph('http://52.83.213.55:7474',user ='******',password = '******')
# graph = Graph('http://localhost:7474',user = '******',password='******')
select = NodeSelector(graph)
# 加载entity
with open('entity.pkl','rb') as f:
entities = pickle.load(f)
entities = list(flatten(entities))
# 添加所有实体为结点
for en in entities:
node = Node('Entity',name= en)
graph.create(node)
# 遍历三元组，添加节点的属性，结点间关系等
for en, kw in triple.items():
node_1 = select.select('Entity').where(name = en).first()
for item in kw:
if item[1] in triple.keys():
node_2 = select.select('Entity').where(name = item[1]).first()
relate = Relationship(node_1,item[0],node_2)
graph.create(relate)
else:
node_1[item[0]] = item[1]
graph.push(node_1)
print('数据存储完毕')
def create_alb():
albs = elbv2.describe_load_balancers()['LoadBalancers']
for alb in albs:
# print(alb)
selector = NodeSelector(graph)
graphVPC = selector.select("VPC", vpcId=alb['VpcId']).first()
tx = graph.begin()
graphAlb = Node("ALB",
name=alb['LoadBalancerName'],
fqdn=alb['DNSName'],
type=alb['Type'],
parent=graphVPC['name'])
rel = Relationship(graphAlb, "EXIST_IN", graphVPC)
tx.create(rel)
tx.merge(graphAlb)
graphFQDN = Node("FQDN", name=alb['DNSName'])
relFQDN = Relationship(graphAlb, "AVAILABLE_ON", graphFQDN)
tx.create(relFQDN)
tx.commit()
albArn = alb['LoadBalancerArn']
# for subnet in alb['AvailabilityZones']:
# tx = graph.begin()
# selector = NodeSelector(graph)
# graphSubnet = selector.select("Subnet",subnetId=subnet['SubnetId']).first()
# rel = Relationship(graphAlb, "BELONGS", graphSubnet)
# tx.create(rel)
# tx.commit()
tgs = elbv2.describe_target_groups(
LoadBalancerArn=albArn)['TargetGroups']
for tg in tgs:
# print(tg)
tgArn = tg['TargetGroupArn']
targets = elbv2.describe_target_health(
TargetGroupArn=tgArn)['TargetHealthDescriptions']
tx = graph.begin()
graphTG = Node("TargetGroup",
name=tg['TargetGroupName'],
protocol=tg['Protocol'],
port=tg['Port'],
parent=graphVPC['name'])
tx.merge(graphTG)
rel = Relationship(graphTG, "EXPOSE_PORT_" + str(tg['Port']),
graphAlb)
tx.create(rel)
tx.commit()
for target in targets:
try:
tx = graph.begin()
selector = NodeSelector(graph)
graphInstance = selector.select(
"EC2", instanceId=target['Target']['Id']).first()
rel = Relationship(graphInstance, "BELONGS", graphTG)
tx.create(rel)
tx.commit()
except:
pass
def find_node(graph, node_name, output=None):
s = NodeSelector(graph)
try:
if (output):
return output(s.select(name=node_name).first())
else:
return s.select(name=node_name).first()
except:
return '没有这个' + node_name + '节点，查询失败'
def search():
print(request.json)
search_type = request.json['search_type']
search_input = request.json['search_input']
database_config = current_app.config['SERVER_CONFIG']['database']
print("[api_v1_app] /search: connecting to neo4j...")
database = Graph("{protocol}://{ip}:{port}".format(
protocol=database_config['connection']['protocol'],
ip=database_config['connection']['ip'],
port=database_config['connection']['port']),
user=database_config['auth']['user'],
password=database_config['auth']['password'])
selector = NodeSelector(database)
if search_type == "operation_system":
records = selector.select("OperationSystem") \
.where("(any(prop in keys(_) where _[prop] CONTAINS '{input}'))".format(input=search_input))
elif search_type == "ftp":
records = selector.select("FTPServer") \
.where("(any(prop in keys(_) where _[prop] CONTAINS '{input}'))".format(input=search_input))
elif search_type == "product":
records = selector.select("ProductSet") \
.where("(any(prop in keys(_) where _[prop] CONTAINS '{input}'))".format(input=search_input))
elif search_type == "all":
records = selector.select() \
.where("(any(prop in keys(_) where _[prop] CONTAINS '{input}'))".format(input=search_input))
else:
result = {
'app': 'npdp-server',
'api': 'search',
'timestamp': time.time(),
'data': {
'status': 'error',
'message': 'type not supported.',
'request': request.form
}
}
return jsonify(result)
result_list = []
for record in records:
node_dict = get_node_dict(record)
result_list.append(node_dict)
result = {
'app': 'npdp-server',
'api': 'search',
'timestamp': time.time(),
'data': {
'status': 'ok',
'request': request.form,
'results': result_list
}
}
return jsonify(result)
def fill_attribute_graph(graph):
# graph.delete_all()
attribute_df = pd.read_csv('data/attributes.csv', usecols=['attribute', 'frequency'])
coexistence_df = pd.read_csv('data/coexistencesProb.csv', usecols=['attribute1','attribute2','totals','exp','diff','weight'])
freq_lookup_dict = dict(zip(attribute_df.attribute.values, attribute_df.frequency.values))
# create nodes
for attribute, frequency in freq_lookup_dict.items():
x = Node('Attribute', attribute=str(attribute), frequency=str(frequency)) # create cypher object
graph.merge(x, 'Attribute', 'attribute') # merge is important to prevent duplicates
# create relationships
for index, row in coexistence_df.iterrows():
rel_type = 'COOCCURS_WITH'
try:
selector = NodeSelector(graph)
attrubute1_node = selector.select("Attribute", attribute=row.attribute1).first()
attrubute2_node = selector.select("Attribute", attribute=row.attribute2).first()
if (attrubute1_node != None
and attrubute2_node != None
and row.totals != None
and row.weight != None):
graph.merge(Relationship(attrubute1_node, rel_type, attrubute2_node, coexistance=row.totals, weight=row.weight))
except AttributeError:
print(index)
print(row)
def get_all_projects(current_user):
#if not current_user.is_admin:
#return jsonify({'message': 'User not authorized!'})
selector = NodeSelector(graph)
projects = selector.select("Project")
projects_list = []
for project in projects:
users_list = []
for rel in graph.match(end_node=project, rel_type="IS_USER"):
user_umcn = rel.start_node()["umcn"]
users_list.append(user_umcn)
admin = ""
for rel in graph.match(end_node=project, rel_type="IS_ADMIN"):
admin_umcn = rel.start_node()["umcn"]
admin = admin_umcn
project_obj = ({
"id": remote(project)._id,
"name": project['name'],
"client": project['client'],
"deadline": project['deadline'],
"priority": project['priority'],
"users": users_list,
"admin": admin
})
projects_list.append(project_obj)
return jsonify(Projects=projects_list)
def get_projects_of_user(current_user, umcn):
selector = NodeSelector(graph)
users = selector.select("Person", umcn=umcn)
user = list(users)[0]
myprojects = []
for rel in graph.match(start_node=user, rel_type="IS_USER"):
project = rel.end_node()
myprojects.append(project)
projects_list = []
for project in myprojects:
users_list = []
for rel in graph.match(end_node=project, rel_type="IS_USER"):
user_umcn = rel.start_node()["umcn"]
users_list.append(user_umcn)
admin = ""
for rel in graph.match(end_node=project, rel_type="IS_ADMIN"):
admin_umcn = rel.start_node()["umcn"]
admin = admin_umcn
project_obj = ({"id": remote(project)._id,
"name": project['name'],
"client": project['client'],
"deadline": project['deadline'],
"priority": project['priority'],
"users": users_list,
"admin": admin
})
projects_list.append(project_obj)
return jsonify(Projects=projects_list)
def find_by_name_exactly_match_for_wikidata(self, name):
try:
selector = NodeSelector(self.graph)
return selector.select("wikidata", labels_en=name).first()
except Exception, error:
_logger.exception()
return None
def node_exist(self, number):
client = Graph(password=os.getenv('NEO4J_PASSWORD', 'Neo4j'))
selector = NodeSelector(client)
selected = selector.select("number", **{"number": number}).first()
if selected:
return selected
return False
def find_wikidata_node(self, wd_item_id):
try:
selector = NodeSelector(self.graph)
return selector.select('wikidata', wd_item_id=wd_item_id).first()
except Exception, error:
_logger.exception()
return None
def node_exists_label_in_list(graph, nodeType, propertyname, propertyvalue,
**kwargs):
"""
Check if a node exists given:
- type
- a property of type list:
- a value to search for in it
On success will return the node.
On failure, will return none
"""
graph = graphs[graph]
selector = NodeSelector(graph)
search1 = selector.select(nodeType)
if search1:
search_res = list(search1)
for ind_res in search_res:
if propertyname in ind_res:
for ind_prop in ind_res[propertyname]:
if ind_prop == propertyvalue:
ind_res["nodeType"] = list(ind_res.labels())[0]
return ind_res
return None
else:
return None
def search_product_by_keywords(keywords):
selector = NodeSelector(graph)
selected = []
by_title = selector.select("Product")\
.where("_.title =~ '.* {0} .*'".format(keywords))\
.limit(12)
selected += list(by_title)
if len(selected) < 12:
by_dscrp = selector.select("Product")\
.where("_.description =~ '.* {0} .*'".format(keywords))\
.limit(12-len(selected))
selected += list(by_dscrp)
return list(selected)
def exists_node(self, label, name):
''' checks to see if a node exists by name '''
print("lookup ", label, " ", name)
g = Graph(password=self.password)
selector = NodeSelector(g)
selected = selector.select(label, name=name)
ret = list(selected)
return len(ret), ret
def add_constant_relationship_test2(self, dict_entities, article_num):
# key = type, "src" = initial , "dst" = destination
selector = NodeSelector(self.graph)
selected = selector.select(article=article_num)
for i, n1 in enumerate(list(selected)):
print("Building links... node ", i, "/", len(list(selected)))
for n2 in list(selected):
if n1 != n2:
self.graph.create(Relationship(n1, "SEMANTIC", n2))
def is_persisted(self):
"""
Check if this already is persisted to neo4j
TODO: Make code less hateable
"""
neo = self.caller.to_neo()
label = list(neo.labels())[0]
neo.update(self.caller.props)
selector = NodeSelector(client)
return len(list(selector.select(label, **dict(neo)))) > 0
def enum_vul(self, TaskID, Cypher_Conditions=None):
if Cypher_Conditions:
# selector.select.where not good for use , not support zh_cn just pure cypher
cypher = 'MATCH (n:HostVul) where n.TaskID="%s" %s RETURN n ' % (TaskID, Cypher_Conditions)
for data in self.graph.data(cypher):
yield data["n"]
else:
selector = NodeSelector(self.graph)
selected = selector.select("HostVul", TaskID=TaskID)
for data in list(selected):
yield data
def new_person(n,y):
selector = NodeSelector(connection.g)
node = selector.select("Person",name=n,born=y)
nodelist=list(node)
if len(nodelist) >1:
EditMovie.popupmsg("Person exists!")
else:
query = "CREATE (a:Person{name:'"+str(n)+"', born:'"+str(y)+"'})"
connection.g.run(query)
time.sleep(5)
EditMovie.controller.show_page("EditMovie")
def get_node_by_uuid(self, node_id):
"""
Retrieve a node from the neo4j database.
:param node_id: THe node to retrieve.
:return: The node
"""
selector = NodeSelector(self.graph_db)
selected = list(selector.select().where('_.name="{}"'.format(node_id)))
if selected:
return selected[0]
return None
def get_nodes_by_properties(self, properties):
"""
:param properties: Dictionary of properties, keys and values.
:return: List of node instances.
"""
conditions = list()
for key in properties.keys():
conditions.append('_.{} = "{}"'.format(key, properties[key]))
selector = NodeSelector(self.graph_db)
selected = selector.select().where(*conditions)
return list(selected)
def add_constant_relationship(self, dict_entities, article_num):
# key = type, "src" = initial , "dst" = destination
selector = NodeSelector(self.graph)
selected = selector.select(article=article_num)
document = Node("DOCUMENT", name=str(article_num), article=article_num)
self.graph.create(document)
for i, n1 in enumerate(list(selected)):
print("Building links... node ", i, "/", len(list(selected)))
self.graph.create(Relationship(n1, "MENTIONED IN", document))
def new_gk(n,type):
selector = NodeSelector(connection.g)
node = selector.select(type,name=n)
nodelist=list(node)
if len(nodelist) >1:
EditMovie.popupmsg("Input already exists!")
else:
query = "CREATE (a:"+type+"{name:'"+str(n)+"'})"
connection.g.run(query)
#EditMovie.popupmsg("done!")
time.sleep(5)
EditMovie.controller.show_page("EditMovie")
def query_node_by_id(node_id):
database_config = current_app.config['SERVER_CONFIG']['database']
print("[api_v1_app] /search: connecting to neo4j...")
database = Graph("{protocol}://{ip}:{port}".format(
protocol=database_config['connection']['protocol'],
ip=database_config['connection']['ip'],
port=database_config['connection']['port']),
user=database_config['auth']['user'],
password=database_config['auth']['password'])
selector = NodeSelector(database)
records = list(selector.select().where(
"id(_)={node_id}".format(node_id=node_id)))
if len(records) == 0:
result = {
'app': 'npdp-server',
'api': 'node/ids',
'timestamp': time.time(),
'data': {
'status': 'error',
'message': "can't find node by id.",
'request': {
'id': node_id
}
}
}
return jsonify(result)
record = records[0]
node_dict = {
'labels': list(record.labels()),
'props': dict(record),
'id': node_id
}
result = {
'app': 'npdp-server',
'api': 'node/ids',
'timestamp': time.time(),
'data': {
'status': 'ok',
'request': {
'id': node_id
},
'node': node_dict
}
}
return jsonify(result)
def create_sg():
securityGroups = ec2.describe_security_groups()
for sg in securityGroups['SecurityGroups']:
# print(sg)
selector = NodeSelector(graph)
graphVPC = selector.select("VPC", vpcId=sg['VpcId']).first()
tx = graph.begin()
graphSg = Node("SecurityGroup",
securityGroupId=sg['GroupId'],
name=sg['GroupName'],
parent=graphVPC['name'])
tx.merge(graphSg)
tx.commit()
def check_for_relation(node1, node2):
graph = Graph('http://localhost:7474/db/data', user='******', password='******')
#neo4j_transaction = graph.begin()
#******************** TYPE ONE METHOD ***************************#
#neo4j_transaction.append(" MATCH (n:Word)-[:CO_OCCURENCED]->(m:Word) RETURN n", n=node1, m=node2)
#************************ TYPE TWO NEO$J ************************#
selector = NodeSelector(graph)
selected1 = selector.select("Word", value=node1)
selected2 = selector.select("Word", value=node2)
#********************* TYPE 3 NEO$j ****************************#
#selected1 = Node("Word",value=node1)
#selected2 = Node("Word",value=node2)
#selected1 = graph.run("MATCH (a:Word) WHERE a.value={b} RETURN a.value", b=node1)
#selected2 = graph.run("MATCH (a:Word) WHERE a.value={b} RETURN a.value", b=node2)
print(selected1)
print(selected2)
#print(dir(selected1.values))
#ab = Relationship(selected1, "CO_OCCURENCED", selected2, bidirectional=True)
#print(ab)
#neo4j_transaction.commit()
#result = neo4j_transaction.commit()
#result = graph.exists(ab)
#******************* TYPE 4 **********************************#
res = graph.match(start_node=selected1, end_node=selected2)
print(res)
#print(result)
if not res:
print("HAI")
neo4j_transaction = graph.begin()
#***************************** TYPE ONE INSERT **************#
#neo4j_transaction.append(" CREATE (n:Word{value:{a}})-[r:CO_OCCURENCED]->(m:Word{value:{b}}) RETURN r", n=node1, m=node2, a=node1, b=node2)
#***************************** TYPE 3 INSERT *****************#
"""selected1 = Node("Word",value=node1)
selected2 = Node("Word",value=node2)
ab = Relationship(selected1, "CO_OCCURENCED", selected2, bidirectional=True)
neo4j_transaction.create(ab)
neo4j_transaction.commit()
result = graph.exists(ab)
print(result)"""
#result = neo4j_transaction.commit()
return 1
def create_ec2():
instances = ec2.describe_instances()
if instances['Reservations'] == []:
pass
else:
for instance in instances['Reservations']:
tx = graph.begin()
instanceId = instance['Instances'][0]['InstanceId']
state = instance['Instances'][0]['State']['Name']
instanceType = instance['Instances'][0]['InstanceType']
selectorInstanceExist = NodeSelector(graph)
graphInstance = selectorInstanceExist.select(
"EC2", instanceId=instanceId).first()
if graphInstance is None:
if not instance['Instances'][0]['State']['Code'] == 48:
subnetId = instance['Instances'][0]['SubnetId']
# print("Subnet ID for instance" + instanceId + " is "+subnetId);
name = ""
if (instance['Instances'][0].__contains__('Tags')):
for tag in instance['Instances'][0]['Tags']:
if tag['Key'] == 'Name':
name = tag['Value']
selectorSubnet = NodeSelector(graph)
graphSubnet = selectorSubnet.select(
"Subnet", subnetId=subnetId).first()
graphEc2 = Node("EC2",
instanceId=instanceId,
name=name,
state=state,
type=instanceType,
parent=graphSubnet['name'])
rel = Relationship(graphEc2, "BELONGS", graphSubnet)
tx.create(rel)
tx.commit()
else:
print("Instance with ID " + instanceId +
" alredy exist in graph DB")
def get_node_by_name(self, name):
"""
Gets a Node by the user's name
Parameters
----------
name : str
A user's name
Returns
-------
Node
Returns a Node (py2neo) if it exists in the graph
"""
selector = NodeSelector(self.graph)
selected = selector.select(name=name)
return selected.first()
def create_rds():
databases = rds.describe_db_instances()['DBInstances']
for db in databases:
print(db)
selector = NodeSelector(graph)
graphVPC = selector.select("VPC",
vpcId=db['DBSubnetGroup']['VpcId']).first()
tx = graph.begin()
graphRds = Node("RDS",
rdsId=db['DBInstanceIdentifier'],
parent=graphVPC['name'])
tx.merge(graphRds)
tx.commit()
tx = graph.begin()
rel = Relationship(graphRds, "BELONGS", graphVPC)
tx.create(rel)
tx.commit()
def login(request):
if request.method=="GET" :
return render (request, "login.html", {})
if request.method=="POST" :
try:
form = request.POST
email = form["email"]
password = form["password"]
except KeyError:
return render (request, "success.html", {"data" : "Some error Occured"})
else:
selector = NodeSelector(graph)
results = selector.select("professor",email=email,password=password).first()
print(results)
if(results==None):
return render (request, "success.html", {"data" : "Incorrect username or password"})
else:
obj = AES.new('This is a key123', AES.MODE_CFB, 'This is an IV456')
message = results['password']
ciphertext = obj.encrypt(message)
#obj2 = AES.new('This is a key123', AES.MODE_CFB, 'This is an IV456')
#obj2.decrypt(ciphertext)
# try :
res = graph.run(
"match (s:student)-[r:UnderProf]->(p:professor) where (p.email=\""+form["email"]+"\") return s.name"
).data()
print (res)
cont = {}
cont["applied"] = [str(row["s.name"]).replace("{","").replace("}","") for row in res ]
print (cont)
cont["profmail"] = form["email"]
return render (request, "profhome.html", cont)
# except :
# return render (request, "profhome.html", {})
# return JsonResponse({"response":"Login Success",
# "name": results['name'],
# "email": results['email'],
# "research": results['research'],
# "vacancy": results['vacancy'],
# "api-token": ciphertext.decode('ISO-8859-1')})
return render (request, "login.html", {})
def get_command_last_run(course_key, graph):
"""
This information is stored on the course node of a course in neo4j
Args:
course_key: a CourseKey
graph: a py2neo Graph
Returns: The datetime that the command was last run, converted into
text, or None, if there's no record of this command last being run.
"""
selector = NodeSelector(graph)
course_node = selector.select(
"course",
course_key=six.text_type(course_key)
).first()
last_this_command_was_run = None
if course_node:
last_this_command_was_run = course_node['time_last_dumped_to_neo4j']
return last_this_command_was_run
def match(graph, definition):
selector = NodeSelector(graph)
result = list(selector.select("Region", **definition))
return result
class Neo4j(DataLayer):
"""Neo4j data layer access for Eve REST API.
"""
serializers = {
'datetime': str_to_date,
'integer': lambda value: int(value) if value is not None else None,
'float': lambda value: float(value) if value is not None else None,
}
def init_app(self, app):
"""Initialize Neo4j.
"""
graph = neo4j.Neo4j(app).gdb
self.driver = NodeSelector(graph)
self.set_defaults(app)
self.register_schema(app)
def set_defaults(self, app):
"""Fill individual resource settings with default settings.
"""
for resource, settings in app.config['DOMAIN'].items():
self._set_resource_defaults(resource, settings)
def _set_resource_defaults(self, resource, settings):
"""Low-level method which sets default values for one resource.
"""
settings.setdefault('datasource', {})
ds = settings['datasource']
ds.setdefault('relation', False)
def register_schema(self, app):
"""Register schema for Neo4j indexes.
:param app: Flask application instance.
"""
for k, v in app.config['DOMAIN'].items():
if 'datasource' in v and 'source' in v['datasource']:
label = v['datasource']['source']
else:
label = k
if 'id_field' in v:
id_field = v['id_field']
else:
id_field = app.config['ID_FIELD']
try:
self.driver.graph.schema.create_uniqueness_constraint(
label, id_field)
except Exception:
pass
def find(self, resource, req, sub_resource_lookup):
""" Retrieves a set of documents matching a given request.
:param resource: resource being accessed. You should then use
the ``datasource`` helper function to retrieve both
the db collection/table and base query (filter), if
any.
:param req: an instance of ``eve.utils.ParsedRequest``. This contains
all the constraints that must be fulfilled in order to
satisfy the original request (where and sort parts, paging,
etc). Be warned that `where` and `sort` expresions will
need proper parsing, according to the syntax that you want
to support with your driver. For example ``eve.io.Mongo``
supports both Python and Mongo-like query syntaxes.
:param sub_resource_lookup: sub-resoue lookup from the endpoint url.
"""
label, filter_, fields, sort = self._datasource_ex(resource, [])
selected = self.driver.select(label)
if req.where:
properties = json.loads(req.where)
selected = selected.where(**properties)
if req.max_results:
selected = selected.limit(req.max_results)
if req.page > 1:
selected = selected.skip((req.page - 1) * req.max_results)
return Neo4jResultCollection(selected)
def find_one(self, resource, req, **lookup):
""" Retrieves a single document/record. Consumed when a request hits an
item endpoint (`/people/id/`).
:param resource: resource being accessed. You should then use the
``datasource`` helper function to retrieve both the
db collection/table and base query (filter), if any.
:param req: an instance of ``eve.utils.ParsedRequest``. This contains
all the constraints that must be fulfilled in order to
satisfy the original request (where and sort parts, paging,
etc). As we are going to only look for one document here,
the only req attribute that you want to process here is
``req.projection``.
:param **lookup: the lookup fields. This will most likely be a record
id or, if alternate lookup is supported by the API,
the corresponding query.
"""
document = self.driver.select(resource, **lookup).first()
return node_to_dict(document) if document else None
def _node_by_id(self, nodeid, resource):
label, _, _, _ = self._datasource_ex(resource, [])
id_field = config.DOMAIN[resource]['id_field']
lookup = {id_field: nodeid}
return self.driver.select(label, **lookup).first()
def insert(self, resource, doc_or_docs):
""" Inserts a document as a node with a label.
:param resource: resource being accessed.
:param doc_or_docs: json document or list of json documents to be added
to the database.
"""
indexes = []
label, _, _, _ = self._datasource_ex(resource, [])
id_field = config.DOMAIN[resource]['id_field']
relation = config.DOMAIN[resource]['datasource']['relation']
schema = config.DOMAIN[resource]['schema']
tx = self.driver.graph.begin()
for document in doc_or_docs:
if relation:
properties = prepare_properties(document)
start_node = self._node_by_id(
properties.pop('start_node'),
schema['start_node']['data_relation']['resource'])
end_node = self._node_by_id(
properties.pop('end_node'),
schema['end_node']['data_relation']['resource'])
relation = Relationship(
start_node, label, end_node, **properties)
relation[id_field] = str(uuid.uuid4())
tx.create(relation)
indexes.append(relation[id_field])
else:
node = create_node(label, document)
node[id_field] = str(uuid.uuid4())
tx.create(node)
indexes.append(node[id_field])
tx.commit()
return indexes
def update(self, resource, id_, updates, original):
""" Updates a graph node.
:param resource: resource being accessed.
:param id_: the unique id of the node.
:param updates: json updates to be performed on the node.
:param original: definition of the json document that should be
updated.
:raise OriginalChangedError: raised if the database layer notices a
change from the supplied `original` parameter.
"""
label, _, _, _ = self._datasource_ex(resource, [])
id_field = config.DOMAIN[resource]['id_field']
filter_ = {id_field: id_}
node = self.driver.select(label, **filter_).first()
if node is None:
abort(500, description=debug_error_message('Object not existent'))
properties = prepare_properties(updates)
node.update(**properties)
self.driver.graph.push(node)
def replace(self, resource, id_, document, original):
""" Replaces a graph node.
:param resource: resource being accessed.
:param id_: the unique id of the node.
:param document: the new json document
:param original: definition of the json document that should be
updated.
:raise OriginalChangedError: raised if the database layer notices a
change from the supplied `original`
parameter.
"""
label, _, _, _ = self._datasource_ex(resource, [])
id_field = config.DOMAIN[resource]['id_field']
filter_ = {id_field: id_}
old_node = self.driver.select(label, **filter_).first()
# Delete the old node
if old_node is None:
abort(500, description=debug_error_message('Object not existent'))
self.remove(resource, filter_)
# create and insert the new one
node = create_node(label, document)
node[id_field] = id_
self.driver.graph.create(node)
def remove(self, resource, lookup={}):
""" Removes a node or an entire set of nodes from a graph label.
:param resource: resource being accessed. You should then use
the ``datasource`` helper function to retrieve
the actual datasource name.
:param lookup: a dict with the query that documents must match in order
to qualify for deletion. For single document deletes,
this is usually the unique id of the document to be
removed.
"""
datasource, filter_, _, _ = self._datasource_ex(resource, lookup)
nodes = self.driver.select(datasource, **filter_)
tx = self.driver.graph.begin()
for node in nodes:
remote_node = node.__remote__
if remote_node:
statement = 'MATCH (_) WHERE id(_)={node_id} DETACH DELETE _'
tx.run(statement, node_id=remote_node._id)
del node.__remote__
tx.commit()