コード例 #1
0
def get_model_node(model):
    # Retreive the name of the model in the database
    model_db_name = "%s:%s" % (model._meta.app_label, model.__name__)
    model_cache_key = "model_node_%s" % model_db_name
    # Use the cache?
    if cache.get(model_cache_key, None) is not None:
        # Simply get the node
        return connection.node.get(cache.get(model_cache_key))
    # Build the query to retreive this model
    query = """
        START n=node(0)
        MATCH n-[r:`<<TYPE>>`]->m
        WHERE HAS(m.name)
        AND m.name = '%s'
        RETURN m
    """ % model_db_name
    # Extract the node for this model
    model_node = connection.query(query, returns=client.Node)
    # Does the node exist for this model?
    if len(model_node):
        # Cache the node id for later
        cache.set(model_cache_key, model_node[0][0].id)
        # And returns it
        return model_node[0][0]
    # The model may not exist YET
    else:
        # We force neo4django to create the model into the database
        # by creating a node from this model
        node = model()
        node.save()
        # Then we delete it instantanetly
        node.delete()
        # And recursivly call this function
        return get_model_node(model)
コード例 #2
0
ファイル: graph.py プロジェクト: IvanJijon/detective.io
def get_model_node(model):
    # Retreive the name of the model in the database
    model_db_name = "%s:%s" % (model._meta.app_label, model.__name__)
    model_cache_key = "model_node_%s" % model_db_name
    # Use the cache?
    if cache.get(model_cache_key, None) is not None:
        # Simply get the node
        return connection.node.get( cache.get(model_cache_key) )
    # Build the query to retreive this model
    query = """
        START n=node(0)
        MATCH n-[r:`<<TYPE>>`]->m
        WHERE HAS(m.name)
        AND m.name = '%s'
        RETURN m
    """ % model_db_name
    # Extract the node for this model
    model_node = connection.query(query, returns=client.Node )
    # Does the node exist for this model?
    if len(model_node):
        # Cache the node id for later
        cache.set(model_cache_key, model_node[0][0].id)
        # And returns it
        return model_node[0][0]
    # The model may not exist YET
    else:
        # We force neo4django to create the model into the database
        # by creating a node from this model
        node = model()
        node.save()
        # Then we delete it instantanetly
        node.delete()
        # And recursivly call this function
        return get_model_node(model)
コード例 #3
0
ファイル: individual.py プロジェクト: IvanJijon/detective.io
 def alter_detail_data_to_serialize(self, request, bundle, nested=False):
     model = self.get_model()
     # Get relationships fields
     fields = [ f for f in model._meta.fields if f.get_internal_type() == 'Relationship']
     node_rels = bundle.obj.node.relationships.all()
     # If the nested parameter is True, this set
     node_to_retreive = set()
     # Resolve relationships manualy
     for field in fields:
         # Get relationships for this fields
         field_rels = [ rel for rel in node_rels[:] if rel.type == field._type]
         # Filter relationships to keep only the well oriented relationships
         # get the related field informations
         related_field = [f for f in iterate_model_fields(model) if "rel_type" in f and f["rel_type"] == field._type and "name" in f and f["name"] == field._BoundRelationship__attname]
         if related_field:
             # Note (edouard): check some assertions in case I forgot something
             assert len(related_field) == 1, related_field
             assert related_field[0]["direction"]
             # choose the end point to check
             end_point_side = "start" if related_field[0]["direction"] == "out" else "end"
             # filter the relationship
             field_rels = [rel for rel in field_rels if getattr(rel, end_point_side).id == bundle.obj.id]
         # Get node ids for those relationships
         field_oposites = [ graph.opposite(rel, bundle.obj.id) for rel in field_rels ]
         # Save the list into properities
         bundle.data[field.name] = field_oposites
         # Nested mode to true: we need to retreive every node
         if nested: node_to_retreive = set(list(node_to_retreive) + field_oposites)
     # There is node to extract for the graph
     if len(node_to_retreive):
         # Build the query to get all node in one request
         query = "start n=node(%s) RETURN ID(n), n" % ",".join(map(str, node_to_retreive))
         # Get all nodes as raw values to avoid unintended request to the graph
         nodes = connection.query(query, returns=(int, dict))
         # Helper lambda to retreive a node
         retreive_node = lambda idx: next(n[1]["data"] for n in nodes if n[0] == idx)
         # Populate the relationships field with there node instance
         for field in fields:
             # Retreive the list of ids
             for i, idx in enumerate(bundle.data[field.name]):
                 rel_node = retreive_node(idx)
                 # Save the id which is not a node property
                 rel_node["id"] = idx
                 # Update value
                 bundle.data[field.name][i] = self.validate(rel_node, field.target_model, allow_missing=True)
     # Show additional field following the model's rules
     rules = request.current_topic.get_rules().model(self.get_model()).all()
     # All additional relationships
     for key in rules:
         # Filter rules to keep only Neomatch instance.
         # Neomatch is a class to create programmaticly a search related to
         # this node.
         if isinstance(rules[key], Neomatch):
             bundle.data[key] = rules[key].query(bundle.obj.id)
     return bundle