Many changes to LDP classes and store strategy:

* Use Resource as an exchange token between LDP and strategy
* Use more `self` and magic
* Move localize/globalize methods to Translator class.

lakesuperior/connectors/graph_store_connector.py

@@ -31,7 +31,8 @@ class GraphStoreConnector:
             self._store = SPARQLUpdateStore(
                     queryEndpoint=self.query_ep,
                     update_endpoint=self.update_ep,
-                    autocommit=False)
+                    autocommit=False,
+                    dirty_reads=True)
 
         return self._store
 
@@ -54,15 +55,17 @@ class GraphStoreConnector:
         self.ds = Dataset(self.store, default_union=True)
         self.ds.namespace_manager = nsm
 
-    def __del__(self):
-        '''Commit pending transactions and close connection.'''
-        self.store.close(True)
+
+    #def __del__(self):
+    #    '''Commit pending transactions and close connection.'''
+    #    self.store.close(True)
 
 
     ## PUBLIC METHODS ##
 
     def query(self, q, initBindings=None, nsc=nsc):
-        '''Perform a custom query on the triplestore.
+        '''
+        Perform a custom query on the triplestore.
 
         @param q (string) SPARQL query.
 
@@ -75,7 +78,8 @@ class GraphStoreConnector:
     ## PROTECTED METHODS ##
 
     def _rdf_cksum(self, g):
-        '''Generate a checksum for a graph.
+        '''
+        Generate a checksum for a graph.
 
         This is not straightforward because a graph is derived from an
         unordered data structure (RDF).
@@ -103,7 +107,8 @@ class GraphStoreConnector:
 
 
     def _non_rdf_checksum(self, data):
-        '''Generate a checksum of non-RDF content.
+        '''
+        Generate a checksum of non-RDF content.
 
         @TODO This can be later reworked to use a custom hashing algorithm.
         '''

lakesuperior/core/namespaces.py

@@ -26,7 +26,7 @@ core_namespaces = {
     'rdfs' : rdflib.namespace.RDFS,
     'fcg' : Namespace('urn:fcgraph:'),
     'fcres' : Namespace('urn:fcres:'),
-    'fcstate' : Namespace('urn:fcstate:'),
+    'fcsystem' : Namespace('urn:fcsystem:'),
     'webac' : Namespace('http://www.w3.org/ns/auth/acl#'),
     'xml' : Namespace('http://www.w3.org/XML/1998/namespace'),
     'xsd' : rdflib.namespace.XSD,

lakesuperior/ldp/ldpr.py

@@ -1,15 +1,48 @@
+import logging
+
 from abc import ABCMeta
 from importlib import import_module
+from itertools import accumulate
 
 import arrow
 
 from rdflib import Graph
-from rdflib.namespace import XSD
+from rdflib.resource import Resource as RdflibResrouce
+from rdflib.namespace import RDF, XSD
 from rdflib.term import Literal
 
 from lakesuperior.config_parser import config
 from lakesuperior.connectors.filesystem_connector import FilesystemConnector
 from lakesuperior.core.namespaces import ns_collection as nsc
+from lakesuperior.util.translator import Translator
+
+
+class ResourceExistsError(RuntimeError):
+    '''
+    Raised in an attempt to create a resource a URN that already exists.
+    '''
+    pass
+
+
+
+def transactional(fn):
+    '''
+    Decorator for methods of the Ldpr class to handle transactions in an RDF
+    store.
+    '''
+    def wrapper(self, *args, **kwargs):
+        try:
+            ret = fn(self, *args, **kwargs)
+            self._logger.info('Committing transaction.')
+            self.gs.conn.store.commit()
+            return ret
+        except:
+            self._logger.info('Rolling back transaction.')
+            self.gs.conn.store.rollback()
+            raise
+
+    return wrapper
+
 
 
 class Ldpr(metaclass=ABCMeta):
@@ -41,8 +74,9 @@ class Ldpr(metaclass=ABCMeta):
     LDP_NR_TYPE = nsc['ldp'].NonRDFSource
     LDP_RS_TYPE = nsc['ldp'].RDFSource
 
-    store_strategy = config['application']['store']['ldp_rs']['strategy']
+    _logger = logging.getLogger(__module__)
 
+    store_strategy = config['application']['store']['ldp_rs']['strategy']
 
     ## MAGIC METHODS ##
 
@@ -50,39 +84,137 @@ class Ldpr(metaclass=ABCMeta):
         '''Instantiate an in-memory LDP resource that can be loaded from and
         persisted to storage.
 
+        Persistence is done in this class. None of the operations in the store
+        strategy should commit an open transaction. Methods are wrapped in a
+        transaction by using the `@transactional` decorator.
+
         @param uuid (string) UUID of the resource.
         '''
+        self.uuid = uuid
+
         # Dynamically load the store strategy indicated in the configuration.
         store_mod = import_module(
                 'lakesuperior.store_strategies.rdf.{}'.format(
                         self.store_strategy))
-        store_cls = getattr(store_mod, self._camelcase(self.store_strategy))
-        self.gs = store_cls()
+        self._rdf_store_cls = getattr(store_mod, self._camelcase(
+                self.store_strategy))
+        self.gs = self._rdf_store_cls(self.urn)
 
         # Same thing coud be done for the filesystem store strategy, but we
         # will keep it simple for now.
         self.fs = FilesystemConnector()
 
-        self.uuid = uuid
-
 
     @property
     def urn(self):
+        '''
+        The internal URI (URN) for the resource as stored in the triplestore.
+        This is a URN that needs to be converted to a global URI for the REST
+        API.
+
+        @return rdflib.URIRef
+        '''
         return nsc['fcres'][self.uuid]
 
 
     @property
     def uri(self):
-        return self.gs.uuid_to_uri(self.uuid)
+        '''
+        The URI for the resource as published by the REST API.
+
+        @return rdflib.URIRef
+        '''
+        return self._uuid_to_uri(self.uuid)
+
+
+    @property
+    def rsrc(self):
+        '''
+        The RDFLib resource representing this LDPR. This is a copy of the
+        stored data if present, and what gets passed to most methods of the
+        store strategy methods.
+
+        @return rdflib.resource.Resource
+        '''
+        if not hasattr(self, '_rsrc'):
+            self._rsrc = self.gs.rsrc
+
+        return self._rsrc
+
+
+    @property
+    def is_stored(self):
+        return self.gs.ask_rsrc_exists()
 
 
     @property
     def types(self):
+        '''All RDF types.
+
+        @return generator
+        '''
+        if not hasattr(self, '_types'):
+            self._types = set(self.rsrc[RDF.type])
+        return self._types
+
+
+    @property
+    def ldp_types(self):
         '''The LDP types.
 
-        @return tuple(rdflib.term.URIRef)
+        @return set(rdflib.term.URIRef)
+        '''
+        if not hasattr(self, '_ldp_types'):
+            self._ldp_types = set()
+            for t in self.types:
+                if t.qname[:4] == 'ldp:':
+                    self._ldp_types.add(t)
+        return self._ldp_types
+
+
+    @property
+    def containment(self):
+        if not hasattr(self, '_containment'):
+            q = '''
+            SELECT ?container ?contained {
+              {
+                ?s ldp:contains ?contained .
+              } UNION {
+                ?container ldp:contains ?s .
+              }
+            }
+            '''
+            qres = self.rsrc.graph.query(q, initBindings={'s' : self.urn})
+
+            # There should only be one container.
+            for t in qres:
+                if t[0]:
+                    container = self.gs.ds.resource(t[0])
+
+            contains = ( self.gs.ds.resource(t[1]) for t in qres if t[1] )
+
+            self._containment = {
+                    'container' : container, 'contains' : contains}
+
+        return self._containment
+
+
+    @containment.deleter
+    def containment(self):
+        '''
+        Reset containment variable when changing containment triples.
         '''
-        return self.gs.list_types(self.uuid)
+        del self._containment
+
+
+    @property
+    def container(self):
+        return self.containment['container']
+
+
+    @property
+    def contains(self):
+        return self.containment['contains']
 
 
     ## LDP METHODS ##
@@ -91,76 +223,218 @@ class Ldpr(metaclass=ABCMeta):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_GET
         '''
-        ret = self.gs.get_rsrc(self.uuid)
-
-        return ret
+        return Translator.globalize_rsrc(self.rsrc)
 
 
+    @transactional
     def post(self, data, format='text/turtle'):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_POST
         '''
-        # @TODO Use gunicorn to get request timestamp.
-        ts = Literal(arrow.utcnow(), datatype=XSD.dateTime)
+        if self.is_stored:
+            raise ResourceExistsError(
+                'Resource #{} already exists. It cannot be re-created with '
+                'this method.'.format(self.urn))
 
         g = Graph()
         g.parse(data=data, format=format, publicID=self.urn)
 
-        data.add((self.urn, nsc['fedora'].lastUpdated, ts))
-        data.add((self.urn, nsc['fedora'].lastUpdatedBy,
-                Literal('BypassAdmin')))
-
-        self.gs.create_rsrc(self.urn, g, ts)
+        self.gs.create_rsrc(g)
 
-        self.gs.conn.store.commit()
+        self._set_containment_rel()
 
 
+    @transactional
     def put(self, data, format='text/turtle'):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_PUT
         '''
-        # @TODO Use gunicorn to get request timestamp.
-        ts = Literal(arrow.utcnow(), datatype=XSD.dateTime)
-
         g = Graph()
         g.parse(data=data, format=format, publicID=self.urn)
 
-        g.add((self.urn, nsc['fedora'].lastUpdated, ts))
-        g.add((self.urn, nsc['fedora'].lastUpdatedBy,
-                Literal('BypassAdmin')))
-
-        self.gs.create_or_replace_rsrc(self.urn, g, ts)
+        self.gs.create_or_replace_rsrc(g)
 
-        self.gs.conn.store.commit()
+        self._set_containment_rel()
 
 
+    @transactional
     def delete(self):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_DELETE
         '''
-        self.gs.delete_rsrc(self.urn, commit=True)
+        self.gs.delete_rsrc(self.urn)
 
 
     ## PROTECTED METHODS ##
 
-    def _create_containment_rel(self):
+    def _set_containment_rel(self):
         '''Find the closest parent in the path indicated by the UUID and
         establish a containment triple.
 
-        E.g. If ONLY urn:res:a exist:
+        E.g.
+
+        - If only urn:fcres:a (short: a) exists:
+          - If a/b/c/d is being created, a becomes container of a/b/c/d. Also,
+            pairtree nodes are created for a/b and a/b/c.
+          - If e is being created, the root node becomes container of e.
+        '''
+        if '/' in self.uuid:
+            # Traverse up the hierarchy to find the parent.
+            #candidate_parent_urn = self._find_first_ancestor()
+            #cparent = self.gs.ds.resource(candidate_parent_urn)
+            cparent_uri = self._find_parent_or_create_pairtree(self.uuid)
+
+            # Reroute possible containment relationships between parent and new
+            # resource.
+            #self._splice_in(cparent)
+            if cparent_uri:
+                self.gs.ds.add((cparent_uri, nsc['ldp'].contains,
+                        self.rsrc.identifier))
+        else:
+            self.rsrc.graph.add((nsc['fcsystem'].root, nsc['ldp'].contains,
+                    self.rsrc.identifier))
+        # If a resource has no parent and should be parent of the new resource,
+        # add the relationship.
+        #for child_uri in self.find_lost_children():
+        #    self.rsrc.add(nsc['ldp'].contains, child_uri)
+
+
+    def _find_parent_or_create_pairtree(self, uuid):
+        '''
+        Check the path-wise parent of the new resource. If it exists, return
+        its URI. Otherwise, create pairtree resources up the path until an
+        actual resource or the root node is found.
+
+        @return rdflib.term.URIRef
+        '''
+        path_components = uuid.split('/')
+
+        if len(path_components) < 2:
+            return None
+
+        # Build search list, e.g. for a/b/c/d/e would be a/b/c/d, a/b/c, a/b, a
+        self._logger.info('Path components: {}'.format(path_components))
+        fwd_search_order = accumulate(
+            list(path_components)[:-1],
+            func=lambda x,y : x + '/' + y
+        )
+        rev_search_order = reversed(list(fwd_search_order))
+
+        cur_child_uri = nsc['fcres'].uuid
+        for cparent_uuid in rev_search_order:
+            cparent_uri = nsc['fcres'][cparent_uuid]
+
+            # @FIXME A bit ugly. Maybe we should use a Pairtree class.
+            if self._rdf_store_cls(cparent_uri).ask_rsrc_exists():
+                return cparent_uri
+            else:
+                self._create_pairtree(cparent_uri, cur_child_uri)
+                cur_child_uri = cparent_uri
+
+        return None
+
+
+    #def _find_first_ancestor(self):
+    #    '''
+    #    Find by logic and triplestore queries the first existing resource by
+    #    traversing a path hierarchy upwards.
+
+    #    @return rdflib.term.URIRef
+    #    '''
+    #    path_components = self.uuid.split('/')
 
-        - If a/b is being created, a becomes container of a/b.
-        - If a/b/c/d is being created, a becomes container of a/b/c/d.
-        - If e is being created, the root node becomes container of e.
-          (verify if this is useful or necessary in any way).
-        - If only a and a/b/c/d exist, and therefore a contains a/b/c/d, and
-        a/b is created:
-          - a ceases to be the container of a/b/c/d
-          - a becomes container of a/b
-          - a/b becomes container of a/b/c/d.
+    #    if len(path_components) < 2:
+    #        return None
+
+    #    # Build search list, e.g. for a/b/c/d/e would be a/b/c/d, a/b/c, a/b, a
+    #    search_order = accumulate(
+    #        reversed(search_order)[1:],
+    #        func=lambda x,y : x + '/' + y
+    #    )
+
+    #    for cmp in search_order:
+    #        if self.gs.ask_rsrc_exists(ns['fcres'].cmp):
+    #            return urn
+    #        else:
+    #            self._create_pairtree_node(cmp)
+
+    #    return None
+
+
+    def _create_pairtree(self, uri, child_uri):
+        '''
+        Create a pairtree node with a containment statement.
+
+        This is the default fcrepo4 behavior and probably not the best one, but
+        we are following it here.
+
+        If a resource such as `fcres:a/b/c` is created, and neither fcres:a or
+        fcres:a/b exists, we have to create pairtree nodes in order to maintain
+        the containment chain.
+
+        This way, both fcres:a and fcres:a/b become thus containers of
+        fcres:a/b/c, which may be confusing.
         '''
-        if self.gs.list_containment_statements(self.urn):
-            pass
+        g = Graph()
+        g.add((uri, RDF.type, nsc['fedora'].Pairtree))
+        g.add((uri, RDF.type, nsc['ldp'].Container))
+        g.add((uri, RDF.type, nsc['ldp'].BasicContainer))
+        g.add((uri, RDF.type, nsc['ldp'].RDFSource))
+        g.add((uri, nsc['ldp'].contains, child_uri))
+        if '/' not in str(uri):
+            g.add((nsc['fcsystem'].root, nsc['ldp'].contains, uri))
+
+        self.gs.create_rsrc(g)
+
+
+
+    #def _splice_in(self, parent):
+    #    '''
+    #    Insert the new resource between a container and its child.
+
+    #    If a resource is inserted between two resources that already have a
+    #    containment relationship, e.g. inserting `<a/b>` where
+    #    `<a> ldp:contains <a/b/c>` exists, the existing containment
+    #    relationship must be broken in order to insert the resource in between.
+
+    #    NOTE: This method only removes the containment relationship between the
+    #    old parent (`<a>` in the example above) and old child (`<a/b/c>`) and
+    #    sets a new one between the new parent and child (`<a/b>` and
+    #    `<a/b/c>`). The relationship between `<a>` and `<a/b>` is set
+    #    separately.
+
+    #    @param rdflib.resource.Resource parent The parent resource. This
+    #    includes the root node.
+    #    '''
+    #    # For some reason, initBindings (which adds a VALUES statement in the
+    #    # query) does not work **just for `?new`**. `BIND` is necessary along
+    #    # with a format() function.
+    #    q = '''
+    #    SELECT ?child {{
+    #      ?p ldp:contains ?child .
+    #      FILTER ( ?child != <{}> ) .
+    #      FILTER STRSTARTS(str(?child), "{}") .
+    #    }}
+    #    LIMIT 1
+    #    '''.format(self.urn)
+    #    qres = self.rsrc.graph.query(q, initBindings={'p' : parent.identifier})
+
+    #    if not qres:
+    #        return
+
+    #    child_urn = qres.next()[0]
+
+    #    parent.remove(nsc['ldp'].contains, child_urn)
+    #    self.src.add(nsc['ldp'].contains, child_urn)
+
+
+    #def find_lost_children(self):
+    #    '''
+    #    If the parent was created after its children and has to find them!
+    #    '''
+    #    q = '''
+    #    SELECT ?child {
+
 
 
     def _camelcase(self, word):
@@ -182,6 +456,7 @@ class LdpRs(Ldpr):
         nsc['ldp'].RDFSource
     }
 
+    @transactional
     def patch(self, data):
         '''
         https://www.w3.org/TR/ldp/#ldpr-HTTP_PATCH
@@ -194,8 +469,6 @@ class LdpRs(Ldpr):
         self.gs.ds.add((self.urn, nsc['fedora'].lastUpdatedBy,
                 Literal('BypassAdmin')))
 
-        self.gs.conn.store.commit()
-
 
 class LdpNr(LdpRs):
     '''LDP-NR (Non-RDF Source).

lakesuperior/store_strategies/rdf/base_rdf_strategy.py

@@ -12,12 +12,6 @@ from lakesuperior.core.namespaces import ns_collection as nsc
 from lakesuperior.core.namespaces import ns_mgr as nsm
 
 
-class ResourceExistsError(RuntimeError):
-    '''Thrown when a resource is being created for an existing URN.'''
-    pass
-
-
-
 class BaseRdfStrategy(metaclass=ABCMeta):
     '''
     This class exposes an interface to build graph store strategies.
@@ -41,10 +35,10 @@ class BaseRdfStrategy(metaclass=ABCMeta):
 
     Some method naming conventions:
 
-    - Methods starting with `get_` return a graph.
-    - Methods starting with `list_` return a list, tuple or set of URIs.
-    - Methods starting with `select_` return a list or tuple with table-like
-      data such as from a SELECT statement.
+    - Methods starting with `get_` return a resource.
+    - Methods starting with `list_` return an iterable or generator of URIs.
+    - Methods starting with `select_` return an iterable or generator with
+      table-like data such as from a SELECT statement.
     - Methods starting with `ask_` return a boolean value.
     '''
 
@@ -55,41 +49,52 @@ class BaseRdfStrategy(metaclass=ABCMeta):
 
     ## MAGIC METHODS ##
 
-    def __init__(self):
+    def __init__(self, urn):
         self.conn = GraphStoreConnector()
         self.ds = self.conn.ds
+        self._base_urn = urn
 
 
-    ## PUBLIC METHODS ##
+    @property
+    def base_urn(self):
+        '''
+        The base URN for the current resource being handled.
 
-    @abstractmethod
-    def ask_rsrc_exists(self, urn):
-        '''Return whether the resource exists.
+        This value is only here for convenience. It does not preclde from using
+        an instance of this class with more than one subject.
+        '''
+        return self._base_urn
 
-        @param uuid Resource UUID.
 
-        @retrn boolean
+    @property
+    def rsrc(self):
         '''
-        pass
+        Reference to a live data set that can be updated. This exposes the
+        whole underlying triplestore structure and is used to update a
+        resource.
+        '''
+        return self.ds.resource(self.base_urn)
 
 
+    @property
     @abstractmethod
-    def get_rsrc(self, urn):
-        '''Get the copy of a resource graph.
-
-        @param uuid Resource UUID.
-
-        @retrn rdflib.resource.Resource
+    def out_graph(self):
+        '''
+        Graph obtained by querying the triplestore and adding any abstraction
+        and filtering to make up a graph that can be used for read-only,
+        API-facing results. Different strategies can implement this in very
+        different ways, so it is an abstract method.
         '''
         pass
 
 
+    ## PUBLIC METHODS ##
+
     @abstractmethod
     def create_or_replace_rsrc(self, urn, data, commit=True):
         '''Create a resource graph in the main graph if it does not exist.
 
-        If it exists, replace the existing one retaining some special
-        properties.
+        If it exists, replace the existing one retaining the creation date.
         '''
         pass
 
@@ -114,103 +119,3 @@ class BaseRdfStrategy(metaclass=ABCMeta):
     @abstractmethod
     def delete_rsrc(self, urn, commit=True):
         pass
-
-
-    def list_containment_statements(self, urn):
-        q = '''
-        SELECT ?container ?contained {
-          {
-            ?s ldp:contains ?contained .
-          } UNION {
-            ?container ldp:contains ?s .
-          }
-        }
-        '''
-        return self.ds.query(q, initBindings={'s' : urn})
-
-
-    def uuid_to_uri(self, uuid):
-        '''Convert a UUID to a URI.
-
-        @return URIRef
-        '''
-        return URIRef('{}rest/{}'.format(request.host_url, uuid))
-
-
-    def localize_string(self, s):
-        '''Convert URIs into URNs in a string using the application base URI.
-
-        @param string s Input string.
-
-        @return string
-        '''
-        return s.replace(
-            request.host_url + 'rest/',
-            str(nsc['fcres'])
-        )
-
-
-    def globalize_string(self, s):
-        '''Convert URNs into URIs in a string using the application base URI.
-
-        @param string s Input string.
-
-        @return string
-        '''
-        return s.replace(
-            str(nsc['fcres']),
-            request.host_url + 'rest/'
-        )
-
-
-    def globalize_term(self, urn):
-        '''Convert an URN into an URI using the application base URI.
-
-        @param rdflib.term.URIRef urn Input URN.
-
-        @return rdflib.term.URIRef
-        '''
-        return URIRef(self.globalize_string(str(urn)))
-
-
-    def globalize_triples(self, g):
-        '''Convert all URNs in a resource or graph into URIs using the
-        application base URI.
-
-        @param rdflib.Graph | rdflib.resource.Resource g Input graph.
-
-        @return rdflib.Graph | rdflib.resource.Resource The same class as the
-        input value.
-        '''
-        if isinstance(g, Resource):
-            return self._globalize_graph(g.graph).resource(
-                    self.globalize_term(g.identifier))
-        elif isinstance (g, Graph):
-            return self._globalize_graph(g)
-        else:
-            raise TypeError('Not a valid input type: {}'.format(g))
-
-
-    def _globalize_graph(self, g):
-        '''Globalize a graph.'''
-        q = '''
-        CONSTRUCT {{ ?s ?p ?o . }} WHERE {{
-          ?s ?p ?o .
-          {{ FILTER STRSTARTS(str(?s), "{0}") . }}
-          UNION
-          {{ FILTER STRSTARTS(str(?o), "{0}") . }}
-        }}'''.format(nsc['fcres'])
-        flt_g = g.query(q)
-
-        for t in flt_g:
-            print('Triple: {}'.format(t))
-            global_s = self.globalize_term(t[0])
-            global_o = self.globalize_term(t[2]) \
-                    if isinstance(t[2], URIRef) \
-                    else t[2]
-            g.remove(t)
-            g.add((global_s, t[1], global_o))
-
-        return g
-
-

lakesuperior/store_strategies/rdf/simple_strategy.py

@@ -1,5 +1,7 @@
 from copy import deepcopy
 
+import arrow
+
 from rdflib import Graph
 from rdflib.namespace import XSD
 from rdflib.term import Literal, URIRef, Variable
@@ -7,7 +9,7 @@ from rdflib.term import Literal, URIRef, Variable
 from lakesuperior.core.namespaces import ns_collection as nsc
 from lakesuperior.core.namespaces import ns_mgr as nsm
 from lakesuperior.store_strategies.rdf.base_rdf_strategy import \
-        BaseRdfStrategy, ResourceExistsError
+        BaseRdfStrategy
 
 
 class SimpleStrategy(BaseRdfStrategy):
@@ -19,99 +21,117 @@ class SimpleStrategy(BaseRdfStrategy):
     for (possible) improved speed and reduced storage.
     '''
 
-    def ask_rsrc_exists(self, urn):
+    @property
+    def out_graph(self):
         '''
-        See base_rdf_strategy.ask_rsrc_exists.
+        See base_rdf_strategy.out_graph.
         '''
-        return (urn, Variable('p'), Variable('o')) in self.ds
+        return self.rsrc.graph
 
 
-    def get_rsrc(self, urn, globalize=True):
+    def ask_rsrc_exists(self):
         '''
-        See base_rdf_strategy.get_rsrc.
+        See base_rdf_strategy.ask_rsrc_exists.
         '''
-        res = self.ds.query(
-            'CONSTRUCT WHERE { ?s ?p ?o }',
-            initBindings={'s' : urn}
-        )
-
-        g = Graph()
-        g += res
-
-        return self.globalize_triples(g) if globalize else g
+        print('Searching for resource: {}'
+                .format(self.rsrc.identifier))
+        return (self.rsrc.identifier, Variable('p'), Variable('o')) in self.ds
 
 
-    def create_or_replace_rsrc(self, urn, g, ts, format='text/turtle',
-            base_types=None, commit=False):
+    def create_or_replace_rsrc(self, g):
         '''
         See base_rdf_strategy.create_or_replace_rsrc.
         '''
-        if self.ask_rsrc_exists(urn):
-            print('Resource exists. Removing.')
-            old_rsrc = deepcopy(self.get_rsrc(urn, False)).resource(urn)
+        # @TODO Use gunicorn to get request timestamp.
+        ts = Literal(arrow.utcnow(), datatype=XSD.dateTime)
 
-            self.delete_rsrc(urn)
-            g.add((urn, nsc['fedora'].created,
-                    old_rsrc.value(nsc['fedora'].created)))
-            g.add((urn, nsc['fedora'].createdBy,
-                    old_rsrc.value(nsc['fedora'].createdBy)))
+        if self.ask_rsrc_exists():
+            self._logger.info(
+                    'Resource {} exists. Removing all outbound triples.'
+                    .format(self.rsrc.identifier))
 
+            # Delete all triples but keep creation date and creator.
+            created = self.rsrc.value(nsc['fedora'].created)
+            created_by = self.rsrc.value(nsc['fedora'].createdBy)
+
+            self.delete_rsrc()
         else:
-            print('New resource.')
-            g.add((urn, nsc['fedora'].created, ts))
-            g.add((urn, nsc['fedora'].createdBy, Literal('BypassAdmin')))
+            created = ts
+            created_by = Literal('BypassAdmin')
+
+        self.rsrc.set(nsc['fedora'].created, created)
+        self.rsrc.set(nsc['fedora'].createdBy, created_by)
+
+        self.rsrc.set(nsc['fedora'].lastUpdated, ts)
+        self.rsrc.set(nsc['fedora'].lastUpdatedBy, Literal('BypassAdmin'))
 
         for s, p, o in g:
             self.ds.add((s, p, o))
 
-        if commit:
-            self.conn.store.commit()
 
-
-    def create_rsrc(self, urn, g, ts, base_types=None, commit=False):
+    def create_rsrc(self, g):
         '''
         See base_rdf_strategy.create_rsrc.
         '''
-        if self.ask_rsrc_exists(urn):
-            raise ResourceExistsError(
-                'Resource #{} already exists. It cannot be re-created with '
-                'this method.'.format(urn))
+        # @TODO Use gunicorn to get request timestamp.
+        ts = Literal(arrow.utcnow(), datatype=XSD.dateTime)
 
-        g.add((self.urn, nsc['fedora'].created, ts))
-        g.add((self.urn, nsc['fedora'].createdBy, Literal('BypassAdmin')))
+        self.rsrc.set(nsc['fedora'].created, ts)
+        self.rsrc.set(nsc['fedora'].createdBy, Literal('BypassAdmin'))
 
         for s, p, o in g:
             self.ds.add((s, p, o))
 
-        if commit:
-            self.conn.store.commit()
-
 
-    def patch_rsrc(self, urn, data, ts, commit=False):
+    def patch_rsrc(self, data):
         '''
         Perform a SPARQL UPDATE on a resource.
         '''
-        q = self.localize_string(data).replace('<>', urn.n3())
-        self.ds.update(q)
+        # @TODO Use gunicorn to get request timestamp.
+        ts = Literal(arrow.utcnow(), datatype=XSD.dateTime)
+
+        q = Translator.localize_string(data).replace(
+                '<>', self.rsrc.identifier.n3())
 
-        if commit:
-            self.conn.store.commit()
+        self.rsrc.set(nsc['fedora'].lastUpdated, ts)
+        self.rsrc.set(nsc['fedora'].lastUpdatedBy, Literal('BypassAdmin'))
 
+        self.ds.update(q)
 
-    def delete_rsrc(self, urn, inbound=False, commit=False):
+
+    def delete_rsrc(self, inbound=False):
         '''
         Delete a resource. If `inbound` is specified, delete all inbound
         relationships as well.
         '''
-        print('Removing resource {}.'.format(urn))
+        print('Removing resource {}.'.format(self.rsrc.identifier))
 
-        self.ds.remove((urn, Variable('p'), Variable('o')))
+        self.rsrc.remove(Variable('p'))
         if inbound:
-            self.ds.remove((Variable('s'), Variable('p'), urn))
-
-        if commit:
-            self.conn.store.commit()
+            self.ds.remove((Variable('s'), Variable('p'), self.rsrc.identifier))
 
 
     ## PROTECTED METHODS ##
 
+    def _unique_value(self, p):
+        '''
+        Use this to retrieve a single value knowing that there SHOULD be only
+        one (e.g. `skos:prefLabel`), If more than one is found, raise an
+        exception.
+
+        @param rdflib.Resource rsrc The resource to extract value from.
+        @param rdflib.term.URIRef p The predicate to serach for.
+
+        @throw ValueError if more than one value is found.
+        '''
+        values = self.rsrc[p]
+        value = next(values)
+        try:
+            next(values)
+        except StopIteration:
+            return value
+
+        # If the second next() did not raise a StopIteration, something is
+        # wrong.
+        raise ValueError('Predicate {} should be single valued. Found: {}.'\
+                .format(set(values)))

lakesuperior/util/translator.py

@@ -0,0 +1,99 @@
+from flask import request
+from rdflib.term import URIRef
+
+from lakesuperior.core.namespaces import ns_collection as nsc
+
+
+class Translator:
+    '''
+    Utility class to perform translations of strings and their wrappers.
+    All static methods.
+    '''
+
+    @staticmethod
+    def uuid_to_uri(uuid):
+        '''Convert a UUID to a URI.
+
+        @return URIRef
+        '''
+        return URIRef('{}rest/{}'.format(request.host_url, uuid))
+
+
+    @staticmethod
+    def localize_string(s):
+        '''Convert URIs into URNs in a string using the application base URI.
+
+        @param string s Input string.
+
+        @return string
+        '''
+        return s.replace(
+            request.host_url + 'rest/',
+            str(nsc['fcres'])
+        )
+
+
+    @staticmethod
+    def globalize_string(s):
+        '''Convert URNs into URIs in a string using the application base URI.
+
+        @param string s Input string.
+
+        @return string
+        '''
+        return s.replace(
+            str(nsc['fcres']),
+            request.host_url + 'rest/'
+        )
+
+
+    @staticmethod
+    def globalize_term(urn):
+        '''
+        Convert an URN into an URI using the application base URI.
+
+        @param rdflib.term.URIRef urn Input URN.
+
+        @return rdflib.term.URIRef
+        '''
+        return URIRef(Translator.globalize_string(str(urn)))
+
+
+    @staticmethod
+    def globalize_graph(g):
+        '''
+        Globalize a graph.
+        '''
+        q = '''
+        CONSTRUCT {{ ?s ?p ?o . }} WHERE {{
+          ?s ?p ?o .
+          {{ FILTER STRSTARTS(str(?s), "{0}") . }}
+          UNION
+          {{ FILTER STRSTARTS(str(?o), "{0}") . }}
+        }}'''.format(nsc['fcres'])
+        flt_g = g.query(q)
+
+        for t in flt_g:
+            print('Triple: {}'.format(t))
+            global_s = Translator.globalize_term(t[0])
+            global_o = Translator.globalize_term(t[2]) \
+                    if isinstance(t[2], URIRef) \
+                    else t[2]
+            g.remove(t)
+            g.add((global_s, t[1], global_o))
+
+        return g
+
+
+    @staticmethod
+    def globalize_rsrc(rsrc):
+        '''
+        Globalize a resource.
+        '''
+        g = rsrc.graph
+        urn = rsrc.identifier
+
+        global_g = Translator.globalize_graph(g)
+        global_uri = Translator.globalize_term(urn)
+
+        return global_g.resource(global_uri)

server.py

@@ -43,7 +43,8 @@ def get_resource(uuid):
     '''
     Retrieve RDF or binary content.
     '''
-    rsrc = LdpRs(uuid).get()
+    # @TODO Add conditions for LDP-NR
+    rsrc = Ldpc(uuid).get()
     if rsrc:
         headers = {
             #'ETag' : 'W/"{}"'.format(ret.value(nsc['premis