def create(time_properties):
query = """
CREATE (tim:Time $props)
RETURN tim.entityID as entityID, tim.name as name, tim.des as description
"""
result = dao.run_write_query(query, props=time_properties).data()
return convert_date_results_to_string(result)
def create_fact(news_id: str, fact_data: Dict):
query = "MATCH (news:News{entityID: $id_news}), " + \
"(sub:" + fact_data['subject_type']+ "{entityID: $id_subject}), " \
"(obj:" + fact_data['object_type'] + "{entityID: $id_object}) " \
"OPTIONAL MATCH (loc:" + fact_data['location_type'] + "{entityID: $id_location})" \
"OPTIONAL MATCH (time:" + fact_data['time_type'] + "{entityID: $id_time})" \
"CREATE (fact:Fact{entityID: $id_fact}), " \
"(news)-[:HAS_FACT]->(fact), " \
"(fact)-[:HAS_SUBJECT_" + fact_data['relation'].replace(" ", "_").upper()+ "]->(sub)," \
"(fact)-[:HAS_OBJECT_" + fact_data["relation"].replace(" ", "_").upper()+ "]->(obj) " \
"FOREACH (_ IN CASE WHEN loc IS NOT NULL THEN [1] ELSE [] END |" \
"CREATE (fact)-[:OCCURRED_IN]->(loc) )" \
"FOREACH (_ IN CASE WHEN time IS NOT NULL THEN [1] ELSE [] END |" \
"CREATE (fact)-[:OCCURRED_ON]->(time) )" \
"RETURN fact.entityID as factID"
result = dao.run_write_query(
query, {
"id_news": news_id,
"id_location": fact_data['location_id'],
"id_time": fact_data["time_id"],
"id_subject": fact_data["subject_id"],
"id_object": fact_data["object_id"],
"id_fact": fact_data["entityID"]
}).data()
return result
def update(agreement_properties: Dict, agr_id: str):
query = """
MATCH (agr:Agreement{entityID: $id_agr})
SET agr = $props
RETURN agr.entityID as entityID, agr.name as name, agr.des as description
"""
return dao.run_write_query(query, {"props":agreement_properties, "id_agr": agr_id}).data()
def update(location_properties: Dict, loc_id: str):
query = """
MATCH (loc:Location{entityID: $id_loc})
SET loc = $props
RETURN loc.entityID as entityID, loc.name as name, loc.des as description
"""
return dao.run_write_query(query, {"props":location_properties, "id_loc": loc_id}).data()
def delete_by_id(news_id: str):
query = """
MATCH (news:News{entityID: $id_news})
USING INDEX news:News(entityID)
OPTIONAL MATCH (news)-[:HAS_FACT]->(fact:Fact)
DETACH DELETE news, fact
"""
return dao.run_write_query(query, id_news=news_id).data()
def createUser(username, password):
query = """
CREATE (usr:User { username: $usr, password: $paswd, isAdmin: $isAd })
RETURN usr.username as username, usr.password as password, usr.isAdmin as isAdmin
"""
return dao.run_write_query(query,
usr=username,
paswd=password,
isAd=False).data()
def update(event_properties: Dict, event_id: str):
query = """
MATCH (event:Event{entityID: $id_event})
SET event = $props
RETURN event.entityID as entityID, event.name as name, event.des as description
"""
return dao.run_write_query(query, {
"props": event_properties,
"id_event": event_id
}).data()
def delete_fact(news_id: str, fact_id: str):
query = """
MATCH (news:News{entityID: $id_news})-[:HAS_FACT]-(fact:Fact{entityID: $id_fact})
USING INDEX news:News(entityID)
DETACH DELETE fact
"""
return dao.run_write_query(query, {
"id_news": news_id,
"id_fact": fact_id
}).data()
def update(country_properties: Dict, cty_id: str):
query = """
MATCH (cty:Country{entityID: $id_cty})
SET cty = $props
RETURN cty.entityID as entityID, cty.name as name, cty.des as description
"""
return dao.run_write_query(query, {
"props": country_properties,
"id_cty": cty_id
}).data()
def update(person_properties: Dict, per_id: str):
query = """
MATCH (per:Person{entityID: $id_per})
SET per = $props
RETURN per.entityID as entityID, per.name as name, per.des as description
"""
return dao.run_write_query(query, {
"props": person_properties,
"id_per": per_id
}).data()
def update(organization_properties: Dict, org_id: str):
query = """
MATCH (org:Organization{entityID: $id_org})
SET org = $props
RETURN org.entityID as entityID, org.name as name, org.des as description
"""
return dao.run_write_query(query, {
"props": organization_properties,
"id_org": org_id
}).data()
def update(time_properties: Dict, tim_id: str):
query = """
MATCH (tim:Time{entityID: $id_tim})
SET tim = $props
RETURN tim.entityID as entityID, tim.name as name, tim.des as description
"""
result = dao.run_write_query(query, {
"props": time_properties,
"id_tim": tim_id
}).data()
return convert_date_results_to_string(result)
def update(news_properties: dict, news_id: str):
query = """
MATCH (news:News{entityID: $id_news})
USING INDEX news:News(entityID)
SET news = $props
RETURN news.entityID as entityID, news.link as link, news.topics as topics
"""
return dao.run_write_query(query, {
"props": news_properties,
"id_news": news_id
}).data()
def merge_nodes(set_entity_id: List[str]) -> Dict:
query = """
UNWIND $entity_id_set as entity_id
MATCH (node:Agreement{entityID: entity_id})
WITH collect(node) as nodes
CALL apoc.refactor.mergeNodes(nodes,
{properties: {entityID: "discard", name:"combine", des:"combine"},
mergeRels:True})
YIELD node
RETURN node.entityID as entityID, node.name as name, node.des as description
"""
result = dao.run_write_query(query, {"entity_id_set": list(set(set_entity_id))}).data()
return result
def merge_nodes(set_entity_id: List[str], entity_type: str) -> Dict:
query = """
UNWIND $entity_id_set as entity_id
MATCH (node {entityID: entity_id})
WHERE $label IN labels(node)
WITH collect(node) as nodes
CALL apoc.refactor.mergeNodes(nodes,
{properties: {entityID: "discard", name:"combine", des:"combine"},
mergeRels:True})
YIELD node
RETURN node
"""
result = dao.run_write_query(query, {
"entity_id_set": list(set(set_entity_id)),
"label": entity_type
}).single()
if (result):
merged_node = result["node"]
return serialize_node_to_dict(merged_node)
else:
return {}
def create(organization_properties):
query = """
CREATE (org:Organization $props)
RETURN org.entityID as entityID, org.name as name, org.des as description
"""
return dao.run_write_query(query, props=organization_properties).data()
def create(country_properties):
query = """
CREATE (cty:Country $props)
RETURN cty.entityID as entityID, cty.name as name, cty.des as description
"""
return dao.run_write_query(query, props=country_properties).data()
def delete(agr_id):
query = """
MATCH (agr: Agreement{entityID: $id_entity})
DELETE agr
"""
return dao.run_write_query(query, id_entity=agr_id).data()
def create(agreement_properties):
query = """
CREATE (agr:Agreement $props)
RETURN agr.entityID as entityID, agr.name as name, agr.des as description
"""
return dao.run_write_query(query, props= agreement_properties).data()
def delete(org_id):
query = """
MATCH (org: Organization{entityID: $id_entity})
DELETE org
"""
return dao.run_write_query(query, id_entity=org_id).data()
def create(event_properties):
query = """
CREATE (event:Event $props)
RETURN event.entityID as entityID, event.name as name, event.des as description
"""
return dao.run_write_query(query, props=event_properties).data()
def delete(cty_id):
query = """
MATCH (cty: Country{entityID: $id_entity})
DELETE cty
"""
return dao.run_write_query(query, id_entity=cty_id).data()
def create(person_properties):
query = """
CREATE (per:Person $props)
RETURN per.entityID as entityID, per.name as name, per.des as description
"""
return dao.run_write_query(query, props=person_properties).data()
def create(news_properties):
query = """
CREATE (news:News $props)
RETURN news.entityID as entityID, news.link as link, news.topics as topics
"""
return dao.run_write_query(query, props=news_properties).data()
def delete(event_id):
query = """
MATCH (event: Event{entityID: $id_entity})
DELETE event
"""
return dao.run_write_query(query, id_entity=event_id).data()
def delete(loc_id):
query = """
MATCH (loc: Location{entityID: $id_entity})
DELETE loc
"""
return dao.run_write_query(query, id_entity=loc_id).data()
def delete(per_id):
query = """
MATCH (per: Person{entityID: $id_entity})
DELETE per
"""
return dao.run_write_query(query, id_entity=per_id).data()
def delete(tim_id):
query = """
MATCH (tim: Time{entityID: $id_entity})
DELETE tim
"""
return dao.run_write_query(query, id_entity=tim_id).data()
def create(location_properties):
query = """
CREATE (loc:Location $props)
RETURN loc.entityID as entityID, loc.name as name, loc.des as description
"""
return dao.run_write_query(query, props= location_properties).data()
