ld4l_virtual_collection 0.1.0

data/app/controllers/ld4l_virtual_collection/tags_controller.rb

@@ -0,0 +1,105 @@
+require_dependency "ld4l_virtual_collection/application_controller"
+
+module Ld4lVirtualCollection
+  class TagsController < ApplicationController
+    before_action :set_collection_and_item, only: [:new, :create, :index]
+    before_action :set_item, only: [:manage_all]
+    before_action :set_tag, only: [:show, :edit, :update, :destroy]
+
+    # GET /collections/1/tags
+    # GET /collections/1/items/1/tags
+    def index
+      @tags = Tag.all(@collection,@item)
+    end
+
+    # GET /tags/1
+    def show
+    end
+
+    # GET /collections/1/tags/new
+    # GET /collections/1/items/1/tags/new
+    def new
+      # puts("*** Entering CTRL: new tag")
+      @tag = Tag.new(@collection,@item)
+    end
+
+    # GET /tags/1/edit
+    def edit
+      # puts("*** Entering CTRL: edit tag")
+    end
+
+    # POST /collections/1/items/1/tags
+    def create
+      # puts("*** Entering CTRL: create tag")
+      @tag = Tag.new(@item, tag_params)
+      # TODO: Any error checking that the ones to delete are deleted and the ones to add are added?
+      if @tag.persist! == true
+        redirect_to my_virtual_collection_path(@collection.id.to_s), notice: 'Tag was successfully created.'
+      else
+        # TODO How to add error message about what failed to persist???
+        render :new
+      end
+    end
+
+    # PATCH/PUT /item/1/tags
+    def manage_all
+      # puts("*** Entering CTRL: manage_all tag")
+      @tags = Tag.update_all(@item, tag_params)
+      @tags[:delete_list].each { |t| t.destroy! }
+      @tags[:add_list].each    { |t| t.persist! }
+      # TODO: Any error checking that the ones to delete are deleted and the ones to add are added?
+      # if @tag.persist! == true
+        redirect_to my_virtual_collection_path(tag_params[:collection_id]), notice: 'Tags were successfully set.'
+      # else
+      #   # TODO How to add error message about what failed to persist???
+      #   render :new
+      # end
+    end
+
+    # PATCH/PUT /tags/1
+    def update
+      # puts("*** Entering CTRL: update tag")
+      @tag = Tag.update(@tag, tag_params)
+      if @tag.persist! == true
+        redirect_to my_virtual_collection_path(@collection.id.to_s), notice: 'Tag were successfully updated.'
+      else
+        # TODO How to add error message about what failed to persist???
+        render :edit
+      end
+    end
+
+    # DELETE /tags/1
+    def destroy
+      # puts("*** Entering CTRL: destroy tag")
+      @tag.destroy
+      # if LD4L::OreRDF::DestroyProxy.call(@collection,@item.rdf_subject) == true
+      redirect_to my_virtual_collection_path(@collection.id.to_s), notice: 'Tag was successfully removed.'
+      # else
+      #   # TODO Should it redirect to edit???  OR list???  OR  where???
+      #   # TODO How to add error message about what failed to be destroyed???
+      #  render :edit
+      # end
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_tag
+        @tag = Tag.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def tag_params
+        params[:tag]
+      end
+
+      def set_collection_and_item
+        @collection = Collection.find(tag_params["collection_id"])
+        @item = Item.find(tag_params["item_id"])
+        @proxy_for = @item && @item.proxy_for && @item.proxy_for.first ? @item.proxy_for.first.rdf_subject : ""
+      end
+
+      def set_item
+        @item = Item.find(tag_params["item_id"])
+      end
+  end
+end

data/app/helpers/ld4l_virtual_collection/application_helper.rb

@@ -0,0 +1,4 @@
+module Ld4lVirtualCollection
+  module ApplicationHelper
+  end
+end

data/app/helpers/ld4l_virtual_collection/collections_helper.rb

@@ -0,0 +1,4 @@
+module Ld4lVirtualCollection
+  module CollectionsHelper
+  end
+end

data/app/helpers/ld4l_virtual_collection/items_helper.rb

@@ -0,0 +1,4 @@
+module Ld4lVirtualCollection
+  module ItemsHelper
+  end
+end

data/app/models/ld4l_virtual_collection/collection.rb

@@ -0,0 +1,47 @@
+require 'ld4l/ore_rdf'
+
+module Ld4lVirtualCollection
+  class Collection < ActiveRecord::Base
+
+    def self.all
+      LD4L::OreRDF::FindAggregations.call(
+          :properties => { :title => RDF::DC.title, :description => RDF::DC.description } )
+    end
+
+    def self.new(*params)
+Ld4lVirtualCollection::Engine.configuration.debug_logger.warn("*** Entering MODEL: new collection")
+      aggregation = LD4L::OreRDF::CreateAggregation.call
+      aggregation.title       = params[0][:title]       if params && params.size > 0 && params[0].has_key?('title')
+      aggregation.description = params[0][:description] if params && params.size > 0 && params[0].has_key?('description')
+      aggregation
+    end
+
+    def self.update(*params)
+Ld4lVirtualCollection::Engine.configuration.debug_logger.warn("*** Entering MODEL: update collection")
+      aggregation = LD4L::OreRDF::ResumeAggregation.call(params[0][:id])
+      aggregation.title       = params[0][:title]       if params && params.size > 0 && params[0].has_key?('title')
+      aggregation.description = params[0][:description] if params && params.size > 0 && params[0].has_key?('description')
+      aggregation
+    end
+
+    def self.destroy
+Ld4lVirtualCollection::Engine.configuration.debug_logger.warn("*** Entering MODEL: destroy collection")
+    end
+
+    def self.find(uri)
+Ld4lVirtualCollection::Engine.configuration.debug_logger.warn("*** Entering MODEL: find collection -- uri=#{uri}")
+      LD4L::OreRDF::ResumeAggregation.call(uri)
+    end
+
+    def self.collections_for_droplist
+Ld4lVirtualCollection::Engine.configuration.debug_logger.warn("*** Entering MODEL: collections_for_droplist")
+      full_collections = Collection.all
+      collections = []
+      full_collections.each do |id,collection|
+        collections << { :title => collection[:title].to_s, :id => id.to_s }
+      end
+      collections
+    end
+
+  end
+end

data/app/models/ld4l_virtual_collection/item.rb

@@ -0,0 +1,50 @@
+require 'ld4l/ore_rdf'
+
+module Ld4lVirtualCollection
+  class Item < ActiveRecord::Base
+
+    def self.all(collection)
+      LD4L::OreRDF::FindProxies.call(
+          :aggregation => collection.id,
+          :properties => { :proxy_for => RDFVocabularies::ORE.proxyFor, :description => RDF::DC.description } )
+    end
+
+    def self.new(collection, *params)
+      # puts("*** Entering MODEL: new item")
+      item_uri = params[0][:proxy_for].strip    if params && params.size > 0 && params[0].has_key?('proxy_for')
+      if(item_uri && item_uri.start_with?("http://da-stg-ssolr.library.cornell.edu/solr/") )
+        add_items_by_query(collection, item_uri)
+      else
+        (item_uri && item_uri.size > 0) ? LD4L::OreRDF::AddAggregatedResource.call( collection, item_uri ) :
+                 LD4L::OreRDF::ProxyResource.new
+    end
+    end
+
+    def self.update(collection, item, *params)
+      # puts("*** Entering MODEL: update item")
+      item_uri = params[0][:proxy_for]       if params && params.size > 0 && params[0].has_key?('proxy_for')
+      item.set_value('proxy_for', item_uri)
+      item
+    end
+
+    def self.destroy(collection,item)
+      # puts("*** Entering MODEL: destroy item")
+
+    end
+
+    def self.find(uri)
+      # puts("*** Entering MODEL: find item")
+      LD4L::OreRDF::ProxyResource.new(uri)
+    end
+
+
+    # TODO XXX
+    def self.add_items_by_query(collection, solr_query)
+      # puts("### Entering MODEL: add_items_by_query #{solr_query}")
+      metadata = LD4L::WorksRDF::GetMetadataFromSolrQuery.call(solr_query, nil)
+      metadata.each do |m|
+        LD4L::OreRDF::AddAggregatedResource.call(collection, m.uri)
+      end
+    end
+  end
+end

data/app/models/ld4l_virtual_collection/note.rb

@@ -0,0 +1,52 @@
+module Ld4lVirtualCollection
+  class Note < ActiveRecord::Base
+
+    def self.all(collection,item)
+      notes = []
+      item_uri = item.id
+      all_annotations_uris = LD4L::OpenAnnotationRDF::Annotation.find_by_target(item_uri)
+      all_annotations_uris.each do |uri|
+        anno = LD4L::OpenAnnotationRDF::Annotation.resume(uri)
+        notes << anno  if anno.kind_of?(LD4L::OpenAnnotationRDF::CommentAnnotation)
+      end
+      notes
+    end
+
+    def self.new(collection,item,*params)
+      # puts("*** Entering MODEL: new note")
+      item_uri = item.id
+      item_uri = RDF::URI(item_uri)  unless item_uri.kind_of?(RDF::URI)
+      note = LD4L::OpenAnnotationRDF::CommentAnnotation.new(ActiveTriples::LocalName::Minter.generate_local_name(
+                      LD4L::OpenAnnotationRDF::CommentAnnotation, 5, {:prefix=>'n'} ))
+      note.hasTarget = item_uri
+      note.setComment("")                    unless params && params.size > 0 && params[0][:new_value]
+      note.setComment(params[0][:new_value]) if     params && params.size > 0 && params[0][:new_value]
+      # note.annotatedBy = p
+      note.setAnnotatedAtNow
+      note
+    end
+
+    def self.update(note,*params)
+      # puts("*** Entering MODEL: update note")
+      item_uri = params.first[:item_id]
+      item_uri = RDF::URI(item_uri)  unless item_uri.kind_of?(RDF::URI)
+      note.hasTarget = item_uri
+      comment = params.first[:new_value]
+      note.setComment(comment)
+      note.setAnnotatedAtNow
+      # note.annotatedBy = p
+      note
+    end
+
+    def self.destroy(note)
+      # puts("*** Entering MODEL: destroy note")
+
+    end
+
+    def self.find(uri)
+      # puts("*** Entering MODEL: find note")
+      LD4L::OpenAnnotationRDF::CommentAnnotation.new(uri)
+    end
+
+  end
+end

data/app/models/ld4l_virtual_collection/tag.rb

@@ -0,0 +1,94 @@
+module Ld4lVirtualCollection
+  class Tag < ActiveRecord::Base
+
+    def self.all(collection,item)
+      # puts("*** Entering MODEL: all tags")
+      self.all_hash(item).to_a
+    end
+
+    def self.all_hash(target)
+      # puts("*** Entering MODEL: all tags as hash")
+      tags = {}
+      target_uri = target.id
+      all_annotations_uris = LD4L::OpenAnnotationRDF::Annotation.find_by_target(target_uri)
+      all_annotations_uris.each do |uri|
+        anno = LD4L::OpenAnnotationRDF::Annotation.resume(uri)
+        tags[anno.getTag] = anno    if anno.kind_of?(LD4L::OpenAnnotationRDF::TagAnnotation)
+      end
+      tags
+    end
+
+    def self.all_values(target)
+      # puts("*** Entering MODEL: values for all tags")
+      self.all_hash(target).keys.join("; ")
+    end
+
+    def self.update_all(target,*params)
+      # puts("*** Entering MODEL: update_all tags")
+      all_anno_hash = self.all_hash(target)
+
+      target_uri = target.id
+      target_uri = RDF::URI(target_uri)  unless target_uri.kind_of?(RDF::URI)
+
+      old_tags = params.first[:old_tags]
+      new_tags = params.first[:new_tags]
+
+      old_tags = old_tags.split(";").collect { |tag_value| tag_value.strip }
+      new_tags = new_tags.split(";").collect { |tag_value| tag_value.strip }
+
+      delete_list = []
+      add_list    = []
+      old_tags.each { |tag_value| delete_list << tag_value  unless new_tags.include? tag_value }
+      new_tags.each { |tag_value| add_list    << tag_value  unless old_tags.include? tag_value }
+
+      delete_list.collect! { |tag_value| all_anno_hash[tag_value] }
+      add_list.collect! do |tag_value|
+        tag = LD4L::OpenAnnotationRDF::TagAnnotation.new(ActiveTriples::LocalName::Minter.generate_local_name(
+                      LD4L::OpenAnnotationRDF::TagAnnotation, 5, {:prefix=>'n'} ))
+        tag.hasTarget = target_uri
+        tag.setTag(tag_value)
+        tag.setAnnotatedAtNow
+        # tag.annotatedBy = p
+        tag
+      end
+      { :delete_list => delete_list, :add_list => add_list }
+    end
+
+    def self.new(collection,item,*params)
+      # puts("*** Entering MODEL: new tag")
+      item_uri = item.id
+      item_uri = RDF::URI(item_uri)  unless item_uri.kind_of?(RDF::URI)
+      tag = LD4L::OpenAnnotationRDF::TagAnnotation.new(ActiveTriples::LocalName::Minter.generate_local_name(
+                                                               LD4L::OpenAnnotationRDF::TagAnnotation, 5, {:prefix=>'n'} ))
+      tag.hasTarget = item_uri
+      tag_value = params.first[:new_value] if params && params.size > 0 && params.has_key?(:new_value)
+      tag.setTag(tag_value)  if tag_value
+      tag.setAnnotatedAtNow
+      # tag.annotatedBy = p
+      tag
+    end
+
+
+    def self.update(tag,*params)
+      # puts("*** Entering MODEL: update tag")
+      item_uri = params.first[:item_id]
+      item_uri = RDF::URI(item_uri)  unless item_uri.kind_of?(RDF::URI)
+      tag.hasTarget = item_uri
+      tag_value = params.first[:new_value]
+      tag.setTag(tag_value)
+      tag.setAnnotatedAtNow
+      # tag.annotatedBy = p
+      tag
+    end
+
+    def self.destroy(tag)
+      # puts("*** Entering MODEL: destroy tag")
+    end
+
+    def self.find(uri)
+      # puts("*** Entering MODEL: find tag")
+      LD4L::OpenAnnotationRDF::TagAnnotation.new(uri)
+    end
+
+  end
+end

data/app/views/layouts/ld4l_virtual_collection/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Ld4lVirtualCollection</title>
+  <%= stylesheet_link_tag    "ld4l_virtual_collection/application", media: "all" %>
+  <%= javascript_include_tag "ld4l_virtual_collection/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/ld4l_virtual_collection/collections/_form.html.erb

@@ -0,0 +1,28 @@
+<%= form_tag( {action: form_action}, method: form_method, id: form_id, class: form_class ) do %>
+    <% if @collection.errors.any? %>
+        <div id="error_explanation">
+          <h2><%= pluralize(@collection.errors.count, "error") %> prohibited this collection from being saved:</h2>
+
+          <ul>
+            <% @collection.errors.full_messages.each do |message| %>
+                <li><%= message %></li>
+            <% end %>
+          </ul>
+        </div>
+    <% end %>
+
+    <%= hidden_field( "collection", "id" ) %>
+
+    <div class="field">
+      <%= label_tag("collection_title", "Title") %>
+      <%= text_field "collection", "title", "size" => 20, "value" => @collection.title %>
+    </div>
+    <div class="field">
+      <%= label_tag("collection_description", "Description") %>
+      <%= text_area "collection", "description", "cols" => 80, "rows" => 8, "value" => @collection.description %>
+    </div>
+
+    <div class="actions">
+      <%= submit_tag("Save") %>
+    </div>
+<% end %>

data/app/views/ld4l_virtual_collection/collections/edit.html.erb

@@ -0,0 +1,13 @@
+<h1>Editing collection</h1>
+
+<%=
+    render :partial =>'form',
+           :locals => {
+              :form_action => 'update',
+              :form_class  => 'edit_collection',
+              :form_id     => "edit_collection_#{@collection.id}",
+              :form_method => 'patch' }
+%>
+
+<%= link_to 'Show', collection_path(@collection.id.to_s) %>
+<%= link_to 'Back', collections_path %>

data/app/views/ld4l_virtual_collection/collections/index.html.erb

@@ -0,0 +1,30 @@
+<p id="notice"><%= notice %></p>
+
+<h1>Listing collections</h1>
+
+<table>
+  <thead>
+  <tr>
+    <th>Title</th>
+    <th>Description</th>
+    <th colspan="3"></th>
+  </tr>
+  </thead>
+
+  <tbody>
+  <% @collections.each do |id,collection| %>
+      <tr>
+        <td><%= collection[:title].to_s %></td>
+        <td><%= collection[:description].to_s %></td>
+        <td><%= link_to 'Show', collection_path(id.to_s) %></td>
+        <td><%= link_to 'Edit', edit_collection_path(id.to_s) %></td>
+        <td><%= link_to 'Destroy', collection_path(id.to_s), method: :delete, data: { confirm: 'Are you sure?' } %></td>
+      </tr>
+  <% end %>
+  </tbody>
+</table>
+
+<br>
+
+<%= link_to 'New Collection', new_collection_path %>
+