ld4l-ore_rdf 0.0.4

data/lib/ld4l/ore_rdf/models/proxy_resource.rb

@@ -0,0 +1,54 @@
+module LD4L
+  module OreRDF
+    class ProxyResource < ActiveTriples::Resource
+
+      class << self; attr_reader :localname_prefix end
+      @localname_prefix="px"
+
+      # configure :base_uri => LD4L::OreRDF.configuration.base_uri, repository => :default
+      configure :type => RDFVocabularies::ORE.Proxy, :base_uri => LD4L::OreRDF.configuration.base_uri, :repository => :default
+
+      property :proxy_for,     :predicate => RDFVocabularies::ORE.proxyFor
+      property :proxy_in,      :predicate => RDFVocabularies::ORE.proxyIn,   :class_name => LD4L::OreRDF::AggregationResource
+      property :next_proxy,    :predicate => RDFVocabularies::IANA.next,     :class_name => LD4L::OreRDF::ProxyResource
+      property :prev_proxy,    :predicate => RDFVocabularies::IANA.prev,     :class_name => LD4L::OreRDF::ProxyResource
+      property :contributor,   :predicate => RDF::DC.contributor,            :class_name => LD4L::FoafRDF::Person   # TODO User who added this item to the Aggregation (default=Aggregation's owner)
+
+
+      # --------------------- #
+      #    HELPER METHODS     #
+      # --------------------- #
+
+
+      ########### NEED TO MOVE TO SERVICE OBJECT ####################
+
+
+      # Returns an array of the LD4L::OreRDF::ProxyResource instances for the items in the aggregation
+      # TODO: How to begin at start and limit to number of returned items, effectively handling ranges of data.
+      def self.get_range( aggregation, start=0, limit=nil )
+        # TODO: Stubbed to return all items.  Need to implement start and limit features.
+
+        # argument validation
+        # raise ArgumentError, 'Argument must be a string with at least one character'  unless
+        #     tag_value.kind_of?(String) && tag_value.size > 0
+
+        graph = ActiveTriples::Repositories.repositories[repository]
+        query = RDF::Query.new({
+                                 :proxy => {
+                                   RDF.type =>  RDFVocabularies::ORE.Proxy,
+                                   RDFVocabularies::ORE.proxyIn => aggregation,
+                                 }
+                               })
+
+        proxies = []
+        results = query.execute(graph)
+        results.each do |r|
+          proxy_uri = r.to_hash[:proxy]
+          proxy = LD4L::OreRDF::ProxyResource.new(proxy_uri)
+          proxies << proxy
+        end
+        proxies
+      end
+    end
+  end
+end

data/lib/ld4l/ore_rdf/services/aggregation/add_aggregated_resource.rb

@@ -0,0 +1,49 @@
+module LD4L
+  module OreRDF
+    class AddAggregatedResource
+
+      ##
+      # Add a single item URI to the items for the aggregation.
+      # Optionally insert the item at the passed position.  Append when position is nil.
+      # NOTE: Ordered lists is currently not supported.  TODO: Implement ordered lists.
+      # TODO: WARNING: This does not look like it would scale.  Getting all, adding to array, and setting all.  Very costly when there are 10s of thousands.
+
+      ##
+      # Adds a resource to the list of aggregated resources for the aggregation inserting at the specified position or
+      # appends to the end if position is not specified.  Creates a proxy object for the resource.
+      #
+      # @param [LD4L::OreRDF::Aggregation] :aggregation to which to add resource
+      # @param [RDF::URI] :resource - URI for the resources to be aggregated
+      # @param [insert_position] :position from beginning of the list of proxies when positive; position from the
+      #    end of the list of proxies when negative
+      #
+      # @returns [LD4L::OreRDF::ProxyResource] the proxy created for the resource
+      def self.call(aggregation,resource,insert_position=nil)
+        raise ArgumentError, "resource must be either a string representation of an URI or an instance of RDF::URI" unless
+            resource.kind_of?(String) || resource.kind_of?(RDF::URI)
+
+        resource = RDF::URI(resource)  unless  resource.kind_of?(RDF::URI)
+
+        # validate aggregation is of correct type
+        raise ArgumentError, "aggregation is not LD4L::OreRDF::Aggregation" unless
+            aggregation.kind_of?(LD4L::OreRDF::Aggregation)
+
+
+        # aggregates = get_values('aggregates')
+        # aggregates << resource_uri
+        # set_value('aggregates',aggregates)
+
+        aggregates = aggregation.aggregates.dup
+        aggregates << resource
+        aggregation.aggregates = aggregates
+
+        LD4L::OreRDF::CreateProxy.call(
+            :resource        => resource,
+            :aggregation     => aggregation,
+            :insert_position => insert_position)
+      end
+
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/aggregation/add_aggregated_resources.rb

@@ -0,0 +1,28 @@
+module LD4L
+  module OreRDF
+    class AddAggregatedResources
+
+      ##
+      # Adds each resource in the resource_array to the list of aggregated resources for the aggregation beginning at
+      # the specified position or appends to the end if position is not specified.  Creates a proxy object for each
+      # resource.
+      #
+      # @param [LD4L::OreRDF::Aggregation] :aggregation to which to add resource
+      # @param [Array<RDF::URI>] resources - array of URIs for the resources to be aggregated
+      # @param [insert_position] :position from beginning of the list of proxies when positive; position from the
+      #    end of the list of proxies when negative
+      #
+      # @returns [Array<LD4L::OreRDF::ProxyResource>] the proxies created for the resources
+      def self.call(aggregation,resources,insert_position=nil)
+        proxy_array = []
+        resources.each do |resource_uri|
+          # TODO should insert_position be different with each iteration; otherwise, won't they go in backwards???
+          proxy_array << LD4L::OreRDF::AddAggregatedResource.call(aggregation,resource_uri,insert_position)
+        end
+        proxy_array
+      end
+
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/aggregation/create.rb

@@ -0,0 +1,39 @@
+module LD4L
+  module OreRDF
+    class CreateAggregation
+
+
+
+
+      # TODO Should this service take an array of resources for the aggregation to aggregate?
+
+
+
+      ##
+      # Create an ore aggregation in one step passing in the required information.
+      #
+      # @param [Hash] options the options to use while generating the aggregation
+      # @option options [String, RDF::URI] :id - uri or localname to use for the rdf_subject of the new aggregation (optional)
+      #                - full URI   - [String, RDF::URI] used as passed in
+      #                - partial id - [String] uri generated from base_uri + localname_prefix + id
+      #                - nil        - uri generated from base_uri + localname_prefix + minted localname
+      # @option options [String] :title - title of the aggregation (optional)
+      # @option options [String] :description - description of the aggregation (optional)
+      # @option options [String, LD4L::FoafRDF::Person] :owner - owner of the aggregation (optional)
+      #
+      # @returns an instance of the new aggregation (not persisted)
+      def self.call( options = {} )
+        id = options[:id] || ActiveTriples::LocalName::Minter.generate_local_name(
+            LD4L::OreRDF::AggregationResource, 10, { :prefix => LD4L::OreRDF::AggregationResource.localname_prefix})
+        aggregation_resource = LD4L::OreRDF::AggregationResource.new(id)
+        aggregation_resource.title       = options[:title]       || []
+        aggregation_resource.description = options[:description] || []
+        aggregation_resource.owner       = options[:owner]       || []
+
+        aggregation = LD4L::OreRDF::Aggregation.new :aggregation_resource => aggregation_resource
+        aggregation
+      end
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/aggregation/destroy.rb

@@ -0,0 +1,47 @@
+module LD4L
+  module OreRDF
+    class DestroyAggregation
+
+      ##
+      # Destroy the aggregation and all associated proxies.
+      #
+      # @param [LD4L::OreRDF::Aggregation] aggregation to be destroyed
+      #
+      # @returns [TrueClass,Hash]
+      #     true if aggregation resource is empty
+      #     true if aggregation resource is not persisted
+      #     true if aggregation resource and all proxy resources were destroyed; otherwise,
+      #     returns Hash with
+      #       :aggregation_resource_destroyed is true if aggregation_resource successfully destroyed; otherwise, false
+      #       :percent_proxies_destroyed is % of proxies successfully destroyed
+      def self.call( aggregation )
+        raise ArgumentError, 'aggregation must be an LD4L::OreRDF::Aggregation'  unless
+            aggregation && aggregation.kind_of?(LD4L::OreRDF::Aggregation)
+
+        return true unless aggregation.aggregation_resource
+        return true unless ActiveTriples::Resource.uri_persisted?(aggregation.aggregation_resource.rdf_subject)
+
+        # have to get actual persisted proxy resources since the ones in the object may not have been persisted
+        proxy_resources = LD4L::OreRDF::FindProxies.call(
+            :aggregation => aggregation.aggregation_resource,
+            :repository  => LD4L::OreRDF::ProxyResource.repository,
+            :resume      => true
+        )
+
+        count = 0
+        total = proxy_resources.size
+        proxy_resources.each { |id,proxy| count += 1 if proxy.destroy! }
+        percent_proxies = total > 0 ? count/total : 1
+        agg_destroyed = percent_proxies == 1 ? aggregation.aggregation_resource.destroy! : false
+        all_destroyed = agg_destroyed && (percent_proxies == 1)
+        ret = all_destroyed ? all_destroyed :
+            {
+                :aggregation_resource_destroyed => agg_destroyed,
+                :percent_proxies_destroyed => percent_proxies
+            }
+        ret
+      end
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/aggregation/destroy_with_id.rb

@@ -0,0 +1,22 @@
+module LD4L
+  module OreRDF
+    class DestroyAggregationWithID
+
+      ##
+      # Destroy the aggregation and all associated proxies.
+      #
+      # @param [String,RDF::URI] uri of aggregation resource to destroy
+      #
+      # @returns [TrueClass,Hash]
+      #     true if aggregation and all proxies destroyed; otherwise,
+      #     returns Hash with
+      #       :aggregation_resource_destroyed is true if aggregation_resource successfully destroyed; otherwise, false
+      #       :percent_proxies_destroyed is % of proxies successfully destroyed
+      def self.call( id )
+        aggregation = LD4L::OreRDF::ResumeAggregation.call(id)
+        LD4L::OreRDF::DestroyAggregation.call(aggregation)
+      end
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/aggregation/find.rb

@@ -0,0 +1,72 @@
+module LD4L
+  module OreRDF
+    class FindAggregations
+
+      ##
+      # Find aggregations matching the specified criteria.
+      #
+      # @param [Hash] options the options to use to find aggregations
+      # @option options [Hash<Object,Object>] :criteria for finding aggregations (ex. RDF::DC.title=>'My Aggregation') (default - nil for all aggregations)
+      # @option options [Hash<Symbol><Object>] :properties to return with the aggregation uri (ex. :first_proxy=>RDFVocabularies::IANA.first) (default - nil aggregation uri only)
+      # @option options [Symbol] :repository to search (default - :default)
+      # @option options [TrueClass,FalseClass] :resume if true, find and resume; otherwise, find only (default - false)
+      #
+      # @returns [Array<RDF::URI>,Hash<RDF::URI,LD4L::OreRDF::Aggregation,Hash<RDF::URI,Hash<Object,Object>]
+      #    if resume==false, returns URIs of matching aggregation resources + specified properties' values;
+      #    otherwise, returns resumed instances of matching aggregations and their proxies
+      #
+      # @example Search for all aggregations
+      #   all_aggs = LD4L::OreRDF.FindAggregations
+      def self.call( options={} )
+        repository = options[:repository] || :default
+        raise ArgumentError, 'repository must be a symbol' unless repository.kind_of?(Symbol)
+        raise ArgumentError, 'repository must be a registered repository' unless
+            ActiveTriples::Repositories.repositories.has_key?(repository)
+
+        resume = options[:resume] || false
+        raise ArgumentError, 'resume must be true or false' unless
+            resume.kind_of?(TrueClass) || resume.kind_of?(FalseClass)
+
+        criteria = options[:criteria] || nil
+        raise ArgumentError, 'criteria must be a hash of attribute-value pairs for searching for aggregations'  unless
+            criteria.nil? || criteria.kind_of?(Hash)
+        criteria = criteria ? criteria.dup : {}
+        criteria[RDF.type] = RDFVocabularies::ORE.Aggregation
+
+        # properties are ignored when resume==true because all properties are returned as part of the resumed aggregations
+        properties = options[:properties] || nil
+        raise ArgumentError, 'properties must be an array of predicates'  unless
+            properties.nil? || properties.kind_of?(Hash) || resume
+        properties.each_key { |k| criteria[properties[k]] = k unless criteria.has_key?(properties[k]) }  unless
+            properties.nil? || resume
+        process_properties = properties.nil? || resume ? false : true
+
+        graph = ActiveTriples::Repositories.repositories[repository]
+        query = RDF::Query.new({ :aggregation => criteria })
+
+        process_properties || resume ? aggregations = {} : aggregations = []
+        results = query.execute(graph)
+        results.each do |r|
+          h = r.to_hash
+          uri = h[:aggregation]
+          if resume
+            # if resume, return Hash of aggregation uri => resumed aggregation for each found
+            aggregations[uri] = LD4L::OreRDF::ResumeAggregation.call(uri)
+          elsif process_properties
+            # if properties, return Hash of aggregation uri => Hash of property => value for each found
+            properties = h
+            properties.delete(:aggregation)
+            aggregations[uri] = properties
+          else
+            # if no properties && not resumed, return array of aggregation uris
+            aggregations << uri
+          end
+        end
+
+        aggregations
+      end
+
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/aggregation/persist.rb

@@ -0,0 +1,34 @@
+module LD4L
+  module OreRDF
+    class PersistAggregation
+
+      ##
+      # Persist the aggregation and all associated proxies.
+      #
+      # @param [LD4L::OreRDF::Aggregation] aggregation to be persisted
+      #
+      # @returns [TrueClass,Hash]
+      #     true if aggregation resource and all proxy resources were persisted; otherwise,
+      #     returns Hash with
+      #       :aggregation_resource_persisted is true if aggregation_resource successfully persisted; otherwise, false
+      #       :percent_proxies_persisted is % of proxies successfully persisted
+      def self.call( aggregation )
+        raise ArgumentError, 'aggregation must be an LD4L::OreRDF::Aggregation'  unless
+            aggregation && aggregation.kind_of?(LD4L::OreRDF::Aggregation)
+
+        count = 0
+        agg_persisted = aggregation.aggregation_resource.persist!
+        aggregation.proxy_resources.each { |proxy| count += 1 if proxy.persist! }  if agg_persisted
+        percent_proxies = aggregation.proxy_resources.size > 0 ? count/aggregation.proxy_resources.size : 1
+        all_persisted = agg_persisted && (percent_proxies == 1)
+        ret = all_persisted ? all_persisted :
+                              {
+                                :aggregation_resource_persisted => agg_persisted,
+                                :percent_proxies_persisted => percent_proxies
+                              }
+        ret
+      end
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/aggregation/resume.rb

@@ -0,0 +1,30 @@
+module LD4L
+  module OreRDF
+    class ResumeAggregation
+
+      ##
+      # Resume the aggregation and all associated proxies.
+      #
+      # @param [String,RDF::URI] uri of aggregation resource to resume
+      #
+      # @returns
+      def self.call( id )
+        raise ArgumentError, 'id must be a local name string, uri string, or RDF::URI'  unless
+            id && ( id.kind_of?(String) || id.kind_of?(RDF::URI) )
+
+        aggregation_resource = LD4L::OreRDF::AggregationResource.new(id)
+        return nil unless ActiveTriples::Resource.uri_persisted?(aggregation_resource.rdf_subject)
+
+        proxy_resources = LD4L::OreRDF::FindProxies.call(
+            :aggregation => aggregation_resource,
+            :repository  => LD4L::OreRDF::ProxyResource.repository,
+            :resume      => true
+        )
+        LD4L::OreRDF::Aggregation.new(
+            :aggregation_resource => aggregation_resource,
+            :proxy_resources      => proxy_resources.values)
+      end
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/services/proxy/create.rb

@@ -0,0 +1,64 @@
+module LD4L
+  module OreRDF
+    class CreateProxy
+
+      ##
+      # Create an ore proxy in one step passing in the required information.
+      #
+      # @param [Hash] options the options to use while generating the proxy
+      # @option options [LD4L::OreRDF::AggregationResource] :aggregation - aggregation to which the resource is being added (required)
+      # @option options [String, RDF::URI] :resource - resource uri for the resource being added to the aggregation (required)
+      # @option options [String, RDF::URI] :id - uri or localname to use for the rdf_subject of the new proxy (optional)(default - mint)
+      #                - full URI   - [String, RDF::URI] used as passed in
+      #                - partial id - [String] uri generated from base_uri + localname_prefix + id
+      #                - nil        - uri generated from base_uri + localname_prefix + minted localname
+      # @option options [Integer] :insert_position - used for ordered lists to place an item at a specific location (optional)(default - appends)
+      # @option options [String, LD4L::FoafRDF::Person] :contributor - person adding the resource (optional)(default - list owner)
+      #
+      # @returns an instance of the new proxy (not persisted)
+      def self.call( options = {} )
+        # validate aggregation was passed in and of correct type
+        aggregation = options[:aggregation] || nil
+        raise ArgumentError, "aggregation is required" if aggregation.nil?
+        raise ArgumentError, "aggregation is not LD4L::OreRDF::Aggregation" unless
+            aggregation.kind_of?(LD4L::OreRDF::Aggregation)
+
+        # validate resource was passed in and of correct type
+        resource = options[:resource] || nil
+        raise ArgumentError, "resource is required" if resource.nil?
+        raise ArgumentError, "resource must be either a string representation of an URI or an instance of RDF::URI" unless
+            resource.kind_of?(String) || resource.kind_of?(RDF::URI)
+
+        # make sure resource is an RDF::URI
+        resource = RDF::URI(resource)  unless  resource.kind_of?(RDF::URI)
+
+        # mint an id if needed
+        id  = options[:id] ||
+            ActiveTriples::LocalName::Minter.generate_local_name(
+                LD4L::OreRDF::ProxyResource, 10, { :prefix => LD4L::OreRDF::ProxyResource.localname_prefix },
+                LD4L::OreRDF.configuration.localname_minter )
+
+        # create the proxy and set properties
+        proxy = LD4L::OreRDF::ProxyResource.new(id)
+        proxy.proxy_for    = resource
+        proxy.proxy_in     = aggregation.aggregation_resource
+        proxy.contributor = options[:contributor] || []   # TODO default to aggregation.owner
+
+        insert_position = options[:insert_position] || nil
+        unless insert_position.nil?
+          # TODO: handle inserting item into an ordered list at position specified
+          # set next_proxy and prev_proxy
+          # update other items that are near it
+          # TODO: what happens if prev and next aren't set on the
+        end
+
+        # TODO - defaulting to appending proxy to the end
+        # TODO - need to update next_proxy, prev_proxy related to ordering
+        aggregation << proxy
+        proxy
+      end
+
+    end
+  end
+end
+