class Target(GraphObject):
__primarylabel__ = "target"
__primarykey__ = "TID"
TID = Property()
name = Property()
longitude = Property()
latitude = Property()
class User(Model):
__primarykey__ = "id"
id = Property("id")
name = Property("name")
email = Property("email")
subscribed_to = RelatedTo(Feed, "SUBSCRIBED")
class Tweet(GraphObject):
id = Property()
text = Property()
retweeted = RelatedTo('Tweet')
replied_to = RelatedTo('Tweet')
mentioned = RelatedTo('User')
class Region(BaseModel):
__primarykey__ = 'name'
name = Property()
population = Property()
country = RelatedTo('Country', 'BELONGS_TO')
class Village(BaseModel):
__primarykey__ = 'name'
name = Property()
population = Property()
district = RelatedTo('District', 'BELONGS_TO')
class Genre(GraphObject):
__primarykey__ = 'name'
name = Property()
description = Property()
preferred = RelatedFrom("User", "PREFER")
class Entity(GraphObject):
__primarykey__ = "eId"
Name = Property()
eId = Property()
Email = Property()
Address = Property()
Tags = Property()
class CodeSet(Model):
__primarykey__ = 'identifier'
identifier: str = Property()
description: str = Property()
uri: str = Property()
members = RelatedTo(ConceptReference, 'HAS_MEMBER')
class Author(GraphObject):
__primarylabel__ = 'author'
id = Property()
authorName = Property()
papers = RelatedTo('Paper', 'publish')
affiliation_ = RelatedTo('Affiliation', 'work_in')
class URL(GraphObject):
__primarykey__ = "path"
path = Property()
domain = Property()
points_at = RelatedTo(IP)
class PermissibleValue(Model):
# Permissible Value
__primarykey__ = 'identifier'
identifier: str = Property()
value: str = Property()
enumerated_value = RelatedFrom(Enumeration, 'HAS_PERMISSIBLE_VALUE')
mappings = RelatedFrom('Mapping', 'MAPPED_FROM')
class Movie(Neo4JManager):
__primarykey__ = "title"
title = Property()
tagline = Property()
actors = RelatedFrom("Person", "ACTED_IN")
class Person(base.BaseModel):
__primarykey__ = 'IdObject'
IdObject = Property()
Name = Property()
NameFamily = Property()
NameFull = Property()
def __init__(self, **kwargs):
super().__init__(**kwargs)
def as_dict(self):
return {
'user_name': self.IdObject,
'first_name': self.Name,
'last_name': self.NameFamily,
'full_name': self.NameFull
}
def fetch(self):
graph = base.get_graph_obj()
person = self.match(graph).where(IdObject=self.IdObject).first()
if person is None:
raise GraphQLError(
f'"{self.IdObject}" has not been found in our employee list.')
return person
class Attribute(ApplicationGraphObject):
__primarykey__ = 'attribute_name'
attribute_name = Property('attribute_name')
value = Property('value')
weight = Property('weight')
bias = Property('bias')
class Receipt(BaseModel):
total_amount = Property()
timestamp = Property()
products = RelatedTo('Product', 'HAS')
def __init__(self, **kwargs):
super().__init__(**kwargs)
if kwargs.get('validate', False):
self.__validate_timestamp()
def as_dict(self):
return {
'_id': self._GraphObject__ogm.node._Entity__remote._id,
'total_amount': self.total_amount,
'timestamp': maya.parse(self.timestamp)
}
def fetch(self, _id):
return self.select(graph, _id).first()
def fetch_products(self):
return [{
**product[0].as_dict(),
**product[1]
} for product in self.products._related_objects]
def __validate_timestamp(self):
try:
maya.parse(self.timestamp, day_first=True, year_first=False)
except Exception:
raise GraphQLError(
'The timestamp you provided is not within the format: "dd/mm/yyyy hh:mm"'
)
class Paper(GraphObject):
__primarylabel__ = 'paper'
id = Property()
title = Property()
authors = RelatedFrom('Author', 'publish')
conference = RelatedTo('Conference', 'publish_on')
class Article(GraphObject):
__primarykey__ = "FullId"
Id = Property()
FullId = Property()
Title = Property()
Marginalia = Property()
Numerical = Property()
paragraphs = RelatedTo("Paragraph", "HAS_PARAGRAPH")
ClassifiedCompilation = RelatedFrom(ClassifiedCompilation, "HAS_ARTICLE")
def __repr__(self):
return "Article[Id={}, FullId={}, Title={}]".format(
self.Id, self.FullId, self.Title)
def toDict(self):
return {
"Id": self.Id,
"FullId": self.FullId,
"Title": self.Title,
"Marginalia": self.Marginalia,
"Numerical": self.Numerical,
"Paragraphs": [p.toDict() for p in self.paragraphs],
"ClassifiedCompilation":
[c.CCNr for c in self.ClassifiedCompilation]
}
class NISTFunction(GraphObject):
"""Neo4j Graph Object (node) representing a NIST Function
"""
__primarykey__ = "id"
id = Property()
title = Property()
class User(GraphObject):
__primarykey__ = "email"
name = Property()
email = Property()
password = Property()
token = Property()
SUBMITS = RelatedTo("Report")
class User(BaseModel):
__primarykey__ = 'email'
email = Property()
first_name = Property()
last_name = Property()
passwod = Property()
def as_dict(self):
return {
'email': self.email,
'first_name': self.first_name,
'last_name': self.last_name,
}
def fetch_by_email(graph, email):
return User.match(graph, email).first()
def fetch_network(graph, email, network_id):
return graph.run("MATCH (u:User)-[r:ATTACHMENT]-(n:Network)\
WHERE u.email='%s' and n.id='%s'\
RETURN u.email" % (email, network_id)).data()
def fetch_networks_available(graph, email, network_id):
return graph.run("MATCH (u:User)-[r]-(n:Network)\
WHERE u.email='%s' and n.id='%s'\
RETURN n.id" % (email, network_id)).data()
def fetchSharedUser(graph, email, network_id):
return graph.run("MATCH (u)-[rel:sharing]->(n) \
WHERE u.email='%s' AND n.id='%s' \
RETURN u" % (email, network_id)).data()
def secure_fetch_by_email(graph, email):
result = graph.run(
"MATCH (user:User) where user.email='%s' REMOVE user.password RETURN user"
% (email)).data()
return result
def unshare(graph, email, network_id):
graph.run("MATCH (u)-[rel:sharing]->(n) \
WHERE u.email='%s' AND n.id='%s' \
DELETE rel" % (email, network_id)).data()
def sharingNetworkAccess(graph, id_network):
result = graph.run(
"MATCH (user:User)-[s:sharing]-(n:Network{id:'%s'}) return user" %
(id_network)).data()
return result
def addNetworkShared(graph, email, id_network):
graph.run(
"MATCH (u:User),(n:Network) WHERE u.email='%s' and n.id='%s' \
create (u)-[s:sharing]->(n)" % (email, id_network)).data()
def fetch_by_email_and_password(graph, email, password):
condicao = "_.email = '{0}' AND _.passwod = '{1}'".format(
email, password)
return User.match(graph, email).where(condicao).first()
class User(GraphObject):
__primarykey__ = 'email'
username = Property()
email = Property()
materials = RelatedTo(Material, 'OWNS')
class Person(GraphObject):
__primarykey__ = 'name'
name = Property()
born = Property()
acted_in = RelatedTo('Movie')
directed = RelatedTo('Movie')
produced = RelatedTo('Movie')
class District(BaseModel):
__primarykey__ = 'name'
name = Property()
population = Property()
region = RelatedTo('Region', 'BELONGS_TO')
class Node(GraphObject):
__primarykey__ = "id"
id = Property()
name = Property()
edges = RelatedTo('Node')
class Server(GraphObject):
__primarykey__ = "name"
name = Property()
ip = Property()
os = RelatedTo(OS, "INSTALED_OS")
cpu_type = Property()
cpu_count = Property()
memory = Property()
def __init__(self, name, ip, ios):
self.name = name
self.ip = ip
self.os.add(ios)
#RelatedTo(OS,relationship_type="HAS_OS")
#Relationship(alice, "KNOWS", bob, since=1999)
#acted_in = RelatedTo(Movie)
#directed = RelatedTo(Movie)
#produced = RelatedTo(Movie)
#actors = RelatedFrom("Person", "ACTED_IN")
#directors = RelatedFrom("Person", "DIRECTED")
#producers = RelatedFrom("Person", "PRODUCED")
#comments = RelatedTo("Comment", "COMMENT")
def __lt__(self, other):
return self.name < other.name
class Graphmv_item(GraphObject):
__primarykey__ = "user"
user = Property()
url = Property()
score = Property()
amigos = RelatedTo("Graphmv_item")
class URL(BaseModel):
__primarykey__ = 'domain'
name = Property()
domain = Property()
# datestamp = Property()
ips = RelatedTo('IP', 'POINTS_TO')
def fetch(self):
url = self.match(graph, self.domain).first()
if url == None:
raise GraphQLError('')
return url
def as_dict(self):
return {
'domain' : self.domain,
'name' : self.name,
# 'datestamp' self.datestamp,
'ips' : self.ips,
}
def __add_link(self, addr, datestamp=None):
ip = IP(addr=addr).fetch()
self.ips.add(ip)
# if datestamp is not None:
# self.datestamp.add(datestamp)
def associate_ip(self, addr, datestamp=None):
#THIS MAY BE TOO SIMPLE.
self.__add_link(addr, datestamp)
class Store(BaseModel):
name = Property()
address = Property()
products = RelatedTo('Product', 'SELLS')
receipts = RelatedTo('Product', 'EMITTED')
def fetch(self, _id):
return Store.select(graph, _id).first()
def fetch_by_name_and_address(self):
return Store.select(graph).where(
f'_.name = "{self.name}" AND _.address = "{self.address}"'
).first()
def fetch_products(self):
return [{
**product[0].as_dict(),
**product[1]
} for product in self.products._related_objects]
def as_dict(self):
return {
'_id': self._GraphObject__ogm.node._Entity__remote._id,
'name': self.name,
'address': self.address
}
class Evaluation(BaseModel):
__primarykey__ = 'rid'
rid = Property()
accuracy = Property()
setup_id = Property()
flow_id = Property()
flow_name = Property()
def __repr__(self):
return f"Evaluation ({self.rid}, {self.accuracy})"
def __eq__(self, other):
if isinstance(other, Evaluation):
return ((self.rid == other.rid) and (self.accuracy == other.accuracy))
else:
return False
def __hash__(self):
return hash(self.__repr__())
def as_dict(self):
return {
'rid': self.rid,
'accuracy': self.accuracy,
'setup_id': self.setup_id,
'flow_id': self.flow_id,
'flow_name': self.flow_name
}
def fetch(self):
evaluation = self.match(graph, self.rid).first()
return evaluation
class GuildMixin(GraphObject):
__primarylabel__ = "Guild"
__primarykey__ = "id"
id = Property()
channel = Property()
support_role = Property()
prefix = Property()
default_scope = Property()
language = Property()
ticket_category = Property()
voice_category = Property()
log_channel = Property()
auto_assigning = Property()
tickets = RelatedFrom("TicketMixin", "TICKET_LOCATED_ON")
responses = RelatedFrom("ResponseMixin", "RESPONSE_LOCATED_ON")
joined_users = RelatedFrom(UserMixin, "JOINED_GUILD")
warnings = RelatedFrom("WarningMixin", "WARNING_EXECUTED_ON")
kicks = RelatedFrom("KickMixin", "KICK_EXECUTED_ON")
bans = RelatedFrom("BanMixin", "BAN_EXECUTED_ON")
blacklist = RelatedFrom(UserMixin, "BLACKLISTED_ON")
reports = RelatedFrom("ReportMixin", "REPORT_ISSUED_ON")
