ld4l-ore_rdf 0.1.0 → 0.2.0

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

@@ -0,0 +1,39 @@
+module LD4L
+  module OreRDF
+    class LoadAggregationFromSolr
+
+      ##
+      # Load the aggregation and all associated proxies from the solr.
+      #
+      # @param [RDF::URI] uri of aggregation resource to load
+      #
+      # @returns
+      def self.call( uri )
+        raise ArgumentError, 'uri must be an RDF::URI'  unless
+            uri && uri.kind_of?(RDF::URI)
+
+        query = ActiveTriples::Solrizer::SolrQueryBuilder.id_query(uri.to_s)
+        results = ActiveTriples::Solrizer::SolrService.query(query)
+        return nil unless results.size > 0
+
+        solr_doc = results.first
+        aggregation_resource = ActiveTriples::Solrizer::IndexingService.load_from_solr_document(solr_doc, true)
+        return nil if aggregation_resource.nil?
+
+        proxy_resources = []
+        proxy_ids = solr_doc[LD4L::OreRDF::AggregationResource.item_proxies_solr_name.to_s]
+        query = ActiveTriples::Solrizer::SolrQueryBuilder.construct_query_for_ids(proxy_ids)
+        results = ActiveTriples::Solrizer::SolrService.query(query)
+        results.each do |solr_doc|
+          proxy_resource = ActiveTriples::Solrizer::IndexingService.load_from_solr_document(solr_doc)
+          proxy_resources << proxy_resource
+        end
+
+        LD4L::OreRDF::Aggregation.new(
+            :aggregation_resource => aggregation_resource,
+            :proxy_resources      => proxy_resources)
+      end
+    end
+  end
+end
+

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

@@ -12,7 +12,7 @@ module LD4L
       #     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 )
+      def self.call( aggregation, index_into_solr=true )
         raise ArgumentError, 'aggregation must be an LD4L::OreRDF::Aggregation'  unless
             aggregation && aggregation.kind_of?(LD4L::OreRDF::Aggregation)
 
@@ -22,7 +22,22 @@ module LD4L
 
         count = 0
         agg_persisted = aggregation.aggregation_resource.persist!
-        aggregation.proxy_resources.each { |proxy| count += 1 if proxy.persist! }  if agg_persisted
+
+        if agg_persisted && index_into_solr
+          aggregation.proxy_resources.each do |proxy|
+            count += 1 if proxy.persist!
+            doc = ActiveTriples::Solrizer::IndexingService.new(proxy).generate_solr_document
+            ActiveTriples::Solrizer::SolrService.add(doc)
+            ActiveTriples::Solrizer::SolrService.commit
+          end
+        end
+
+        if index_into_solr
+          doc = aggregation.aggregation_resource.generate_solr_document
+          ActiveTriples::Solrizer::SolrService.add(doc)
+          ActiveTriples::Solrizer::SolrService.commit
+        end
+
         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 :

data/lib/ld4l/ore_rdf/version.rb

@@ -1,5 +1,5 @@
 module LD4L
   module OreRDF
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/spec/ld4l/ore_rdf/configuration_spec.rb

@@ -4,7 +4,7 @@ describe 'LD4L::OreRDF' do
 
   describe '#configuration' do
     after(:all) do
-      ActiveTriples::RDFSource.type_registry.keys.each { |k| ActiveTriples::RDFSource.type_registry.delete(k) } if Object.const_defined?("ActiveTriples::RDFSource")
+      ActiveTriples::RDFSource.type_registry.keys.each { |k| ActiveTriples::RDFSource.type_registry.delete(k) } if Object::ActiveTriples.const_defined?("RDFSource")
     end
 
     describe "base_uri" do

data/spec/ld4l/ore_rdf/models/aggregation_resource_spec.rb

@@ -212,6 +212,65 @@ describe 'LD4L::OreRDF::AggregationResource' do
   #  START -- Test helper methods specific to this model
   # -----------------------------------------------------
 
+  describe '#generate_solr_document' do
+    before do
+      ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      @person = LD4L::FoafRDF::Person.new('http://example.org/person1')
+      @aggregation = LD4L::OreRDF::CreateAggregation.call( :id=>'http://example.org/moomin', :title=>'My Resources',
+                                                           :description=>'Resources that I like', :owner=>@person )
+    end
+
+    context 'when aggregation has 0 proxies' do
+      it 'should return a solr doc with all fields' do
+        expected_solr_doc = {:id=>"http://example.org/moomin",
+                             :at_model_ssi=>"LD4L::OreRDF::AggregationResource",
+                             :object_profile_ss=>
+                                 "{\"id\":\"http://example.org/moomin\",\"title\":[\"My Resources\"],\"description\":[\"Resources that I like\"],\"owner\":\"http://example.org/person1\",\"aggregates\":[],\"first_proxy_\":[],\"last_proxy_\":[]}",
+                             :title_ti=>"My Resources",
+                             :title_ssort=>"My Resources",
+                             :description_ti=>"Resources that I like",
+                             :owner_ssi=>"http://example.org/person1",
+                             :item_proxies_ssm=>[]}
+        expect(@aggregation.aggregation_resource.generate_solr_document(@aggregation.proxy_resources)).to eq expected_solr_doc
+      end
+    end
+
+    context 'when aggregation has proxies' do
+      let(:proxies) do
+        [LD4L::OreRDF::AddAggregatedResource.call( @aggregation,'http://example.org/resource_1'),
+         LD4L::OreRDF::AddAggregatedResource.call( @aggregation,'http://example.org/resource_2'),
+         LD4L::OreRDF::AddAggregatedResource.call( @aggregation,'http://example.org/resource_3')]
+      end
+
+      it 'should return a solr doc with all fields' do
+        object_profile = "{\"id\":\"http://example.org/moomin\",\"title\":[\"My Resources\"],\"description\":[\"Resources that I like\"],\"owner\":\"http://example.org/person1\",\"aggregates\":[\"http://example.org/resource_1\",\"http://example.org/resource_2\",\"http://example.org/resource_3\"],\"first_proxy_\":\"#{proxies.first.id}\",\"last_proxy_\":\"#{proxies.last.id}\"}"
+        proxy_ids = proxies.collect { |p| p.id }
+        expected_solr_doc = {:id=>"http://example.org/moomin",
+                             :at_model_ssi=>"LD4L::OreRDF::AggregationResource",
+                             :object_profile_ss=>object_profile,
+                             :title_ti=>"My Resources",
+                             :title_ssort=>"My Resources",
+                             :description_ti=>"Resources that I like",
+                             :owner_ssi=>"http://example.org/person1",
+                             :aggregates_tsim=>
+                                 ["http://example.org/resource_1", "http://example.org/resource_2", "http://example.org/resource_3"],
+                             :item_proxies_ssm=>proxy_ids }
+        expect(@aggregation.aggregation_resource.generate_solr_document(@aggregation.proxy_resources)).to eq expected_solr_doc
+      end
+    end
+
+    context 'when aggregation has no owner' do
+      xit 'should return without owner information' do
+        pending 'this needs to be implemented'
+      end
+    end
+
+    context 'when aggregation has owner' do
+      xit 'should return with owner information' do
+        pending 'this needs to be implemented'
+      end
+    end
+  end
 
   ########### NEED TO MOVE TO SERVICE OBJECT ####################
 
@@ -379,10 +438,10 @@ describe 'LD4L::OreRDF::AggregationResource' do
           vci_array = subject.get_items
           vci_array.each do |vci|
             expect(vci).to be_a(LD4L::OreRDF::ProxyResource)
-            expect(vci.proxy_in.first).to eq subject
+            expect(vci.proxy_in_.first).to eq subject
           end
           results = []
-          vci_array.each { |vci| results << vci.proxy_for.first }
+          vci_array.each { |vci| results << vci.proxy_for_.first }
           expect(results).to include "http://example.org/individual/b1"
           expect(results).to include "http://example.org/individual/b2"
           expect(results).to include "http://example.org/individual/b3"

data/spec/ld4l/ore_rdf/models/proxy_resource_spec.rb

@@ -62,14 +62,33 @@ describe 'LD4L::OreRDF::ProxyResource' do
     end
   end
 
-  describe 'proxy_for' do
+  describe 'proxy_for_' do
     it "should be empty array if we haven't set it" do
-      expect(subject.proxy_for).to match_array([])
+      expect(subject.proxy_for_).to match_array([])
+    end
+
+    it "should be settable" do
+      subject.proxy_for_ = "http://example.org/b1"
+      expect(subject.proxy_for_.first).to eq "http://example.org/b1"
+    end
+
+    it "should be changeable" do
+      orig_proxy_for = "http://example.org/b1"
+      new_proxy_for  = "http://example.org/b1_NEW"
+      subject.proxy_for_ = orig_proxy_for
+      subject.proxy_for_ = new_proxy_for
+      expect(subject.proxy_for_.first).to eq new_proxy_for
+    end
+  end
+
+  describe 'proxy_for' do
+    it "should be nil if we haven't set it" do
+      expect(subject.proxy_for).to be_nil
     end
 
     it "should be settable" do
       subject.proxy_for = "http://example.org/b1"
-      expect(subject.proxy_for.first).to eq "http://example.org/b1"
+      expect(subject.proxy_for).to eq "http://example.org/b1"
     end
 
     it "should be changeable" do
@@ -77,19 +96,39 @@ describe 'LD4L::OreRDF::ProxyResource' do
       new_proxy_for  = "http://example.org/b1_NEW"
       subject.proxy_for = orig_proxy_for
       subject.proxy_for = new_proxy_for
-      expect(subject.proxy_for.first).to eq new_proxy_for
+      expect(subject.proxy_for).to eq new_proxy_for
     end
   end
 
-  describe 'proxy_in' do
+  describe 'proxy_in_' do
     it "should be empty array if we haven't set it" do
-      expect(subject.proxy_in).to match_array([])
+      expect(subject.proxy_in_).to match_array([])
+    end
+
+    it "should be settable" do
+      an_aggregation = LD4L::OreRDF::AggregationResource.new('1')
+      subject.proxy_in_ = an_aggregation
+      expect(subject.proxy_in_.first).to eq an_aggregation
+    end
+
+    it "should be changeable" do
+      orig_aggregation = LD4L::OreRDF::AggregationResource.new('1')
+      new_aggregation = LD4L::OreRDF::AggregationResource.new('2')
+      subject.proxy_in_ = orig_aggregation
+      subject.proxy_in_ = new_aggregation
+      expect(subject.proxy_in_.first).to eq new_aggregation
+    end
+  end
+
+  describe 'proxy_in' do
+    it "should be nil if we haven't set it" do
+      expect(subject.proxy_in).to be_nil
     end
 
     it "should be settable" do
       an_aggregation = LD4L::OreRDF::AggregationResource.new('1')
       subject.proxy_in = an_aggregation
-      expect(subject.proxy_in.first).to eq an_aggregation
+      expect(subject.proxy_in).to eq an_aggregation
     end
 
     it "should be changeable" do
@@ -97,19 +136,45 @@ describe 'LD4L::OreRDF::ProxyResource' do
       new_aggregation = LD4L::OreRDF::AggregationResource.new('2')
       subject.proxy_in = orig_aggregation
       subject.proxy_in = new_aggregation
-      expect(subject.proxy_in.first).to eq new_aggregation
+      expect(subject.proxy_in).to eq new_aggregation
+    end
+
+    it "should be able to get rdf_subject" do
+      an_aggregation = LD4L::OreRDF::AggregationResource.new('http://www.example.org/agg1')
+      subject.proxy_in = an_aggregation
+      expect(subject.proxy_in_subject).to eq 'http://www.example.org/agg1'
     end
   end
 
-  describe 'next_proxy' do
+  describe 'next_proxy_' do
     it "should be empty array if we haven't set it" do
-      expect(subject.next_proxy).to match_array([])
+      expect(subject.next_proxy_).to match_array([])
+    end
+
+    it "should be settable" do
+      an_proxy = LD4L::OreRDF::ProxyResource.new('1')
+      subject.next_proxy_ = an_proxy
+      expect(subject.next_proxy_.first).to eq an_proxy
+    end
+
+    it "should be changeable" do
+      orig_proxy = LD4L::OreRDF::ProxyResource.new('1')
+      new_proxy = LD4L::OreRDF::ProxyResource.new('2')
+      subject.next_proxy_ = orig_proxy
+      subject.next_proxy_ = new_proxy
+      expect(subject.next_proxy_.first).to eq new_proxy
+    end
+  end
+
+  describe 'next_proxy' do
+    it "should be nil if we haven't set it" do
+      expect(subject.next_proxy).to be_nil
     end
 
     it "should be settable" do
       an_proxy = LD4L::OreRDF::ProxyResource.new('1')
       subject.next_proxy = an_proxy
-      expect(subject.next_proxy.first).to eq an_proxy
+      expect(subject.next_proxy).to eq an_proxy
     end
 
     it "should be changeable" do
@@ -117,19 +182,45 @@ describe 'LD4L::OreRDF::ProxyResource' do
       new_proxy = LD4L::OreRDF::ProxyResource.new('2')
       subject.next_proxy = orig_proxy
       subject.next_proxy = new_proxy
-      expect(subject.next_proxy.first).to eq new_proxy
+      expect(subject.next_proxy).to eq new_proxy
+    end
+
+    it "should be able to get subject" do
+      an_proxy = LD4L::OreRDF::ProxyResource.new('http://www.example.org/proxy1')
+      subject.next_proxy = an_proxy
+      expect(subject.next_proxy_subject).to eq 'http://www.example.org/proxy1'
     end
   end
 
-  describe 'prev_proxy' do
+  describe 'prev_proxy_' do
     it "should be empty array if we haven't set it" do
-      expect(subject.prev_proxy).to match_array([])
+      expect(subject.prev_proxy_).to match_array([])
+    end
+
+    it "should be settable" do
+      an_proxy = LD4L::OreRDF::ProxyResource.new('1')
+      subject.prev_proxy_ = an_proxy
+      expect(subject.prev_proxy_.first).to eq an_proxy
+    end
+
+    it "should be changeable" do
+      orig_proxy = LD4L::OreRDF::ProxyResource.new('1')
+      new_proxy = LD4L::OreRDF::ProxyResource.new('2')
+      subject.prev_proxy_ = orig_proxy
+      subject.prev_proxy_ = new_proxy
+      expect(subject.prev_proxy_.first).to eq new_proxy
+    end
+  end
+
+  describe 'prev_proxy' do
+    it "should be nil if we haven't set it" do
+      expect(subject.prev_proxy).to be_nil
     end
 
     it "should be settable" do
       an_proxy = LD4L::OreRDF::ProxyResource.new('1')
       subject.prev_proxy = an_proxy
-      expect(subject.prev_proxy.first).to eq an_proxy
+      expect(subject.prev_proxy).to eq an_proxy
     end
 
     it "should be changeable" do
@@ -137,7 +228,13 @@ describe 'LD4L::OreRDF::ProxyResource' do
       new_proxy = LD4L::OreRDF::ProxyResource.new('2')
       subject.prev_proxy = orig_proxy
       subject.prev_proxy = new_proxy
-      expect(subject.prev_proxy.first).to eq new_proxy
+      expect(subject.prev_proxy).to eq new_proxy
+    end
+
+    it "should be able to get subject" do
+      an_proxy = LD4L::OreRDF::ProxyResource.new('http://www.example.org/proxy1')
+      subject.prev_proxy = an_proxy
+      expect(subject.prev_proxy_subject).to eq 'http://www.example.org/proxy1'
     end
   end
 
@@ -288,7 +385,7 @@ describe 'LD4L::OreRDF::ProxyResource' do
             expect(vci.proxy_in.first).to eq vc
           end
           results = []
-          vci_array.each { |vci| results << vci.proxy_for.first }
+          vci_array.each { |vci| results << vci.proxy_for_.first }
           expect(results).to include "http://example.org/individual/b1"
           expect(results).to include "http://example.org/individual/b2"
           expect(results).to include "http://example.org/individual/b3"
@@ -406,8 +503,8 @@ describe 'LD4L::OreRDF::ProxyResource' do
           subject.reload
           expect(subject.contributor).to eq ["John Smith"]
           subject.contributor = []
-          subject.proxy_in = []
-          subject.proxy_for = []
+          subject.proxy_in_ = []
+          subject.proxy_for_ = []
           expect(subject.contributor).to eq []
           subject.persist!
           subject.reload
@@ -444,8 +541,8 @@ describe 'LD4L::OreRDF::ProxyResource' do
           subject.reload
           expect(subject.contributor).to eq ["John Smith"]
           subject.contributor = []
-          subject.proxy_in = []
-          subject.proxy_for = []
+          subject.proxy_in_ = []
+          subject.proxy_for_ = []
           expect(subject.contributor).to eq []
           subject.persist!
           subject.reload
@@ -515,7 +612,7 @@ describe 'LD4L::OreRDF::ProxyResource' do
     end
 
     it 'should contain data' do
-      expect(subject.attributes['proxy_for']).to eq ['Dummy Proxy']
+      expect(subject.attributes['proxy_for_']).to eq ['Dummy Proxy']
     end
 
     it 'should contain child objects' do
@@ -562,8 +659,8 @@ describe 'LD4L::OreRDF::ProxyResource' do
 
   describe 'property methods' do
     it 'should set and get properties' do
-      subject.proxy_for = 'Comet in Moominland'
-      expect(subject.proxy_for).to eq ['Comet in Moominland']
+      subject.proxy_for_ = 'Comet in Moominland'
+      expect(subject.proxy_for_).to eq ['Comet in Moominland']
     end
   end
 
@@ -612,7 +709,7 @@ describe 'LD4L::OreRDF::ProxyResource' do
     it 'should delete properties when statements are removed' do
       subject << RDF::Statement.new(subject.rdf_subject, RDFVocabularies::ORE.proxyFor, 'Comet in Moominland')
       subject.delete RDF::Statement.new(subject.rdf_subject, RDFVocabularies::ORE.proxyFor, 'Comet in Moominland')
-      expect(subject.proxy_for).to eq []
+      expect(subject.proxy_for_).to eq []
     end
   end
 

data/spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resource_spec.rb

@@ -28,8 +28,8 @@ describe 'LD4L::OreRDF::AggregationResource::AddAggregatedResource' do
 
     it "should generate the resource instance for a single resource" do
       proxy = LD4L::OreRDF::AddAggregatedResource.call( subject, RDF::URI("http://example.org/individual/b1" ))
-      expect(proxy.proxy_for.first).to eq "http://example.org/individual/b1"
-      expect(proxy.proxy_in.first).to eq subject.aggregation_resource
+      expect(proxy.proxy_for_.first).to eq "http://example.org/individual/b1"
+      expect(proxy.proxy_in_.first).to eq subject.aggregation_resource
     end
   end
 

data/spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resources_spec.rb

@@ -63,11 +63,11 @@ describe 'LD4L::OreRDF::AddAggregatedResources' do
            RDF::URI("http://example.org/individual/b3")])
       proxy_array.each do |proxy|
         expect(proxy).to be_a(LD4L::OreRDF::ProxyResource)
-        expect(proxy.proxy_in.first).to eq subject.aggregation_resource
+        expect(proxy.proxy_in_.first).to eq subject.aggregation_resource
       end
       results = []
       proxy_array.each do |proxy|
-        results << proxy.proxy_for.first
+        results << proxy.proxy_for_.first
       end
       expect(results).to include "http://example.org/individual/b1"
       expect(results).to include "http://example.org/individual/b2"

data/spec/ld4l/ore_rdf/services/aggregation/destroy_spec.rb

@@ -27,12 +27,13 @@ describe 'LD4L::OreRDF::DestroyAggregation' do
     context "when aggregation doesn't have proxies" do
       before do
         ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+
         @id = "http::/example.org/NO_PROXIES"
         @aggregation = LD4L::OreRDF::CreateAggregation.call(
             id:          @id,
             title:       "No Proxy Aggregation",
             description: "Test aggregation with no proxies." )
-        LD4L::OreRDF::PersistAggregation.call(@aggregation)
+        LD4L::OreRDF::PersistAggregation.call(@aggregation,false)
         expect( LD4L::OreRDF::ResumeAggregation.call(@id).rdf_subject.to_s ).to eq @id
       end
       after do
@@ -48,6 +49,7 @@ describe 'LD4L::OreRDF::DestroyAggregation' do
     context "when aggregation has proxies" do
       before do
         ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+
         @id1 = "http::/example.org/ag1"
         @ag1 = LD4L::OreRDF::CreateAggregation.call(
             id:          @id1,
@@ -58,7 +60,7 @@ describe 'LD4L::OreRDF::DestroyAggregation' do
             [RDF::URI("http://example.org/individual/b11"),
              RDF::URI("http://example.org/individual/b12"),
              RDF::URI("http://example.org/individual/b13")])
-        LD4L::OreRDF::PersistAggregation.call(@ag1)
+        LD4L::OreRDF::PersistAggregation.call(@ag1,false)
         a1 = LD4L::OreRDF::ResumeAggregation.call(@id1)
         expect( a1.aggregation_resource.rdf_subject.to_s ).to eq @id1
         expect( a1.proxy_resources.length).to eq 3
@@ -74,7 +76,7 @@ describe 'LD4L::OreRDF::DestroyAggregation' do
             [RDF::URI("http://example.org/individual/b21"),
              RDF::URI("http://example.org/individual/b22"),
              RDF::URI("http://example.org/individual/b23")])
-        LD4L::OreRDF::PersistAggregation.call(@ag2)
+        LD4L::OreRDF::PersistAggregation.call(@ag2,false)
         a2 = LD4L::OreRDF::ResumeAggregation.call(@id2)
         expect( a2.aggregation_resource.rdf_subject.to_s ).to eq @id2
         expect( a2.proxy_resources.length).to eq 3
@@ -85,7 +87,7 @@ describe 'LD4L::OreRDF::DestroyAggregation' do
             title:       "Aggregation 3",
             description: "Test description of aggregation 3.",
             owner:       p )
-        LD4L::OreRDF::PersistAggregation.call(@ag3)
+        LD4L::OreRDF::PersistAggregation.call(@ag3,false)
         a3 = LD4L::OreRDF::ResumeAggregation.call(@id3)
         expect( a3.aggregation_resource.rdf_subject.to_s ).to eq @id3
         expect( a3.proxy_resources.length).to eq 0