Пример #1
0
 def test_can_get_node_by_id_when_not_cached(self):
     node = Node()
     self.graph.create(node)
     Node.cache.clear()
     assert remote(node).uri not in Node.cache
     got = self.graph.node(remote(node)._id)
     assert remote(got)._id == remote(node)._id
Пример #2
0
 def test_can_create_dbms_with_trailing_slash(self):
     uri = "http://localhost:7474/"
     dbms = DBMS(uri)
     assert repr(dbms).startswith("<DBMS")
     assert remote(dbms).uri == uri
     index = remote(dbms).get().content
     assert "data" in index
Пример #3
0
 def test_can_create_dbms_with_bolt_uri(self):
     uri = "bolt://localhost/"
     dbms = DBMS(uri)
     assert repr(dbms).startswith("<DBMS")
     assert remote(dbms).uri == "http://localhost:7474/"
     index = remote(dbms).get().content
     assert "data" in index
Пример #4
0
 def test_can_create_dbms_with_settings(self):
     uri = "http://127.0.0.1:7474/"
     dbms = DBMS(host="127.0.0.1")
     assert repr(dbms).startswith("<DBMS")
     assert remote(dbms).uri == uri
     index = remote(dbms).get().content
     assert "data" in index
Пример #5
0
 def test_can_create_remote_node(self):
     a = Node("Person", name="Alice", age=33)
     self.graph.create(a)
     assert set(a.labels()) == {"Person"}
     assert dict(a) == {"name": "Alice", "age": 33}
     assert remote(a).ref.startswith("node/")
     assert repr(remote(a))
Пример #6
0
 def test_graph(self):
     a = Node()
     b = Node()
     r = Relationship(a, "TO", b)
     self.graph.create(r)
     assert remote(r)
     assert remote(r).graph == Graph("http://localhost:7474/db/data/")
Пример #7
0
 def test_can_bind_node_to_resource(self):
     uri = "http://localhost:7474/db/data/node/1"
     node = Node()
     node.__remote__ = RemoteEntity(uri)
     assert remote(node)
     assert isinstance(remote(node), Resource)
     assert remote(node).uri == uri
Пример #8
0
def api_v1_topology_nodes():
    edges = []
    for record in neo4j_connect.data('MATCH (n) return n'):
        source = record['n']

        for rel in neo4j_connect.match(source, rel_type='isl'):
            dest = rel.end_node()

            s = Link()
            s.label = source['name']
            s.id = py2neo.remote(source)._id

            t = Link()
            t.label = dest['name']
            t.id = py2neo.remote(dest)._id

            edge = Edge()
            edge.value = "{} to {}".format(s.label, t.label)
            edge.source = s
            edge.target = t

            edges.append(edge)

    edges.sort(key=lambda x: (x.source['id'], x.target['id']))
    nodes = Nodes()
    nodes.edges = edges

    return nodes.toJSON()
Пример #9
0
 def test_can_get_relationship_by_id_when_not_cached(self):
     a = Node()
     b = Node()
     r = Relationship(a, "TO", b)
     self.graph.create(r)
     Relationship.cache.clear()
     got = self.graph.relationship(remote(r)._id)
     assert remote(got)._id == remote(r)._id
Пример #10
0
 def test_minimal_node_hydrate(self):
     dehydrated = {
         "self": "http://localhost:7474/db/data/node/0",
     }
     hydrated = Node.hydrate(dehydrated)
     assert isinstance(hydrated, Node)
     assert remote(hydrated)
     assert remote(hydrated).uri == dehydrated["self"]
Пример #11
0
 def test_can_create_entity_with_initial_uri_and_metadata(self):
     uri = "http://localhost:7474/db/data/node/1"
     metadata = {"foo": "bar"}
     entity = Node()
     entity.__remote__ = RemoteEntity(uri, metadata)
     assert remote(entity)
     assert remote(entity).uri == uri
     assert remote(entity).metadata == metadata
Пример #12
0
 def test_can_merge_with_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)
     self.graph.merge(node, "A", "a")
     assert remote(node)._id == a_id
     assert remote(node)._id != b_id
Пример #13
0
 def test_can_create_relationship(self):
     a = Node("Person", name="Alice")
     b = Node("Person", name="Bob")
     r = Relationship(a, "KNOWS", b, since=1999)
     with self.graph.begin() as tx:
         tx.create(r)
     assert remote(a)
     assert remote(b)
     assert remote(r)
     assert r.start_node() == a
     assert r.end_node() == b
Пример #14
0
 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
Пример #15
0
 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
Пример #16
0
 def test_can_bind_relationship_to_resource(self):
     uri = "http://localhost:7474/db/relationship/1"
     metadata = {
         "start": "http://localhost:7474/db/node/1",
         "end": "http://localhost:7474/db/node/2",
     }
     relationship = Relationship({}, "", {})
     # Pass in metadata to avoid callback to server
     relationship.__remote__ = RemoteEntity(uri, metadata=metadata)
     assert remote(relationship)
     assert isinstance(remote(relationship), Resource)
     assert remote(relationship).uri == uri
Пример #17
0
 def test_node_hydrate_with_properties(self):
     dehydrated = {
         "self": "http://localhost:7474/db/data/node/0",
         "data": {
             "name": "Alice",
             "age": 33,
         },
     }
     hydrated = Node.hydrate(dehydrated)
     assert isinstance(hydrated, Node)
     assert dict(hydrated) == dehydrated["data"]
     assert remote(hydrated)
     assert remote(hydrated).uri == dehydrated["self"]
Пример #18
0
 def test_can_merge_relationship_that_does_not_exist(self):
     alice = Node("Person", name="Alice")
     bob = Node("Person", name="Bob")
     ab = Relationship(alice, "KNOWS", bob)
     old_order = order(self.graph)
     old_size = size(self.graph)
     self.graph.merge(ab)
     assert remote(alice)
     assert remote(bob)
     assert remote(ab)
     assert self.graph.exists(alice | bob | ab)
     new_order = order(self.graph)
     new_size = size(self.graph)
     assert new_order == old_order + 2
     assert new_size == old_size + 1
Пример #19
0
    def add(current_user_id, task_id, data):

        all_attributes = ["client", "date", "message", "user"]

        date_created = str(datetime.datetime.now()).replace(' ', 'T') + "Z"

        try:
            new_note = Node("Note",
                            client=data['client'],
                            date=data['date'],
                            message=data['message'])
        except KeyError as e:
            return {"message": f"You are missing a key element: {e}"}

        new_note['date_created'] = date_created
        new_note['user'] = current_user_id

        graph.create(new_note)

        task = graph.run(
            f"MATCH (task:Task) WHERE ID(task)={task_id} RETURN task"
        ).evaluate()

        note_task_rel = Relationship(new_note, 'IS_NOTE_OF', task)
        graph.create(note_task_rel)

        new_note['id'] = remote(new_note)._id

        return new_note
Пример #20
0
    def add(data):

        date_created = str(datetime.datetime.now()).replace(' ', 'T') + "Z"

        try:
            new_project = Node("Project",
                               name=data['name'],
                               deadline=data['deadline'],
                               priority=data['priority'],
                               client=data['client'],
                               state=data['state'])
            new_project['date_created'] = date_created
            admins = data['admins']
            users = data['users']
        except KeyError as e:
            return {"message": f"You are missing a key element: {e}"}

        graph.create(new_project)

        admins = data.get('admins')
        users = data.get('users')

        users_msg = Project.make_connections(users, new_project, "IS_USER")
        admins_msg = Project.make_connections(admins, new_project, "IS_ADMIN")

        if users_msg.get('message'):
            return users_msg
        if admins_msg.get('message'):
            return admins_msg

        new_project['id'] = remote(new_project)._id
        return new_project
Пример #21
0
 def test_can_init_server_plugin(self):
     remote_graph = remote(self.graph)
     metadata = remote_graph.metadata
     metadata["extensions"]["FakePlugin"] = {}
     self.graph.__remote__ = Resource(remote_graph.uri, metadata)
     plugin = FakePlugin(self.graph)
     assert plugin.resources == {}
Пример #22
0
def create_task(current_user):
    data = request.get_json()

    new_task = Node("Task",
                    name=data['name'],
                    priority=data['priority'],
                    state=data['state'],
                    thumbnail=data['thumbnail'],
                    deadline=data['deadline'],
                    download=data['download'],
                    created=data['created'],
                    finished=data['finished'],
                    upload=data['upload'],
                    description=data['description'])

    graph.create(new_task)

    project_id = data["project"]
    project = graph.run(
        f"MATCH (project:Project) WHERE ID(project)={project_id} RETURN project"
    ).data()[0]["project"]

    task_project = Relationship(new_task, 'IS_TASK_OF', project)
    graph.create(task_project)

    new_task['project'] = project_id
    new_task['id'] = remote(new_task)._id

    return jsonify(new_task)
Пример #23
0
def login():
    auth = request.authorization

    if not auth or not auth.username or not auth.password:
        return make_response('Could not verify', 401, {'WWW-Authenticate': 'Basic realm="Login required"'})

    #user = session.query(User).filter_by(email=auth.username).first()
    user = graph.run("MATCH (user:Person) WHERE user.email = '{authuser}' RETURN user".format(authuser=auth.username))
    user_id = remote(user.evaluate())._id
    print(user_id)
    user = graph.run("MATCH (user:Person) WHERE user.email = '{authuser}' RETURN user".format(authuser=auth.username))
    user_data = list(user)[0][0]
    print(user_data)
    print(user_data["password"])

    if not user:
        return make_response('Could not verify', 401, {'WWW-Authenticate': 'Basic realm="Login required"'})

    if check_password_hash(user_data["password"], auth.password):
        token = jwt.encode({'user_id': user_id},
                           app.config['SECRET_KEY'])

        # if user.check_password(auth.password):
    #     token = jwt.encode({'user_id': user.id, 'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=30)}, app.config['SECRET_KEY'])

        return jsonify({'token': token.decode('UTF-8')})

    return make_response('Could not verify', 401, {'WWW-Authenticate': 'Basic realm="Login required"'})
Пример #24
0
 def test_bound_node_equality(self):
     alice_1 = Node(name="Alice")
     alice_1.__remote__ = RemoteEntity("http://localhost:7474/db/data/node/1")
     Node.cache.clear()
     alice_2 = Node(name="Alice")
     alice_2.__remote__ = RemoteEntity(remote(alice_1).uri)
     assert alice_1 == alice_2
Пример #25
0
 def test_can_cast_node(self):
     alice = Node(name="Alice")
     self.graph.create(alice)
     casted = cast(alice)
     assert isinstance(casted, Node)
     assert remote(casted)
     assert casted["name"] == "Alice"
Пример #26
0
 def test_can_get_relationship_by_id_when_cached(self):
     a = Node()
     b = Node()
     r = Relationship(a, "TO", b)
     self.graph.create(r)
     got = self.graph.relationship(remote(r)._id)
     assert got is r
Пример #27
0
def set_link_props(tx, isl, props):
    match = _make_match(isl)
    q = textwrap.dedent("""
        MATCH (target:link_props {
            src_switch: $src_switch,
            src_port: $src_port,
            dst_switch: $dst_switch,
            dst_port: $dst_port})
        RETURN target""")

    logger.debug('link_props lookup query:\n%s', q)
    cursor = tx.run(q, match)

    try:
        target = db.fetch_one(cursor)['target']
    except exc.DBEmptyResponse:
        raise exc.DBRecordNotFound(q, match)

    origin, update = _locate_changes(target, props)
    if update:
        q = textwrap.dedent("""
        MATCH (target:link_props) 
        WHERE id(target)=$target_id
        """) + db.format_set_fields(db.escape_fields(update),
                                    field_prefix='target.')

        logger.debug('Push link_props properties: %r', update)
        tx.run(q, {'target_id': py2neo.remote(target)._id})

        sync_with_link_props(tx, isl, *update.keys())

    return origin
Пример #28
0
 def createNewNodeWithLabel(self, nodeName, label):
     """Creates a new node with the given label """
     tx = self.begin(autocommit=False)
     newNode = Node(label, name=nodeName)
     tx.create(newNode)
     tx.commit()
     return remote(newNode)._id
Пример #29
0
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)
Пример #30
0
    def find_users(task, connection_type):
        users_list = []
        for rel in graph.match(end_node=task, rel_type=connection_type):
            user_id = remote(rel.start_node())._id
            users_list.append(user_id)

        return users_list
Пример #31
0
def create_node(new_node):
    node = Node(new_node["label"], **new_node["properties"])
    graph.create(node)
    response = {
        "label": new_node["label"],
        "id": remote(node)._id,
        "properties": dict(node)
    }

    return json.jsonify({"node":response})
Пример #32
0
def create_link(new_node_data):
    s = graph.node(int(new_node_data["source_id"]))
    t = graph.node(int(new_node_data["target_id"]))
    relationship = Relationship(s, new_node_data["label"], t, **new_node_data["properties"])
    graph.merge(relationship)
    response = {
        "label": relationship.type(),
        "id": remote(relationship)._id,
        "source": new_node_data["source_id"],
        "target": new_node_data["target_id"],
        "properties": new_node_data["properties"]
    }
    return json.jsonify({"link": response})
Пример #33
0
 def get_property_keys(self):
     if not self.property_keys:
         self.property_keys = sorted(remote(self.graph).resolve("propertykeys").get().content)
     return self.property_keys
Пример #34
0
 def get_constraints(self):
     if not self.constraints:
         data = remote(self.graph).resolve("schema/constraint").get().content
         self.constraints = sort_dict_by_key(data, "label")
     return self.constraints
Пример #35
0
 def get_indexes(self):
     if not self.indexes:
         data = remote(self.graph).resolve("schema/index").get().content
         self.indexes = sort_dict_by_key(data, "label")
     return self.indexes