Begins to integrate the form functionality for the EphemeraBox and Ep…

…hemeraFolder resources within EphemeraProjects

Adding routing and minimal support for EphemeraFolders

Implementing a first attempt at supporting EphemeraBox membership and improving the routes for EphemeraBoxes and EphemeraFolders

Ensuring that Resources can have IIIF Manifests exposed using the class method "can_have_manifests?"; Ensuring that EphemeraProjects and EphemeraBoxes are linked using the ContextualPath

Implementing the attributes for the EphemeraFolders; Resolving issues for ScannedResources

Integrating support for membership within EphemeraFolders

Tracking files being merge after the latest rebase

Adding the Factories and test suites for the Ephemera Decorators

Extending the test coverage for the Ephemera* Controllers and Decorators

Don't create a real property for append_id

Append_id is a virtual property in Valkyrie that exists on ChangeSets.
It's not something we want to persist - it's something we act on in a
ChangeSetPersister.

Extending the coverage for the Ephemera Decorators; Adding test coverage for the EphemeraBox and Folder ChangeSets

Increasing the test coverage for EphemeraFolders and the ephemera editor role

Clean up box show view.

Ensures that IIIF Manifests are properly structured for EphemeraFolders

Add Ephemera Folder Workflow

Also DRYs this up a bit to make it easier to add another workflow later.

Implementing the EphemeraVocabulary Class; Customizing and extending the View templates for EphemeraFields and EphemeraVocabulary objects

Increasing the test coverage for Ephemera Vocabularies

Extending the coverage for the EphemeraController

Resolving a typo. error in the parent breadcrumbs partial

Linking EphemeraFolders to vocabulary terms for EphemeraFields

Ensures that errors encountered in EphemeraFields are handled properly

Extending the coverage for Ephemera* Controllers and access permissions

app/change_sets/ephemera_box_change_set.rb

@@ -16,7 +16,6 @@ class EphemeraBoxChangeSet < Valhalla::ChangeSet
   validate :barcode_valid?
 
   def barcode_valid?
-    # return if barcode.present? && barcode.first.match(/^\d+{14}$/)
     return if Barcode.new(Array.wrap(barcode).first).valid?
     errors.add(:barcode, 'has an invalid checkdigit')
   end

app/change_sets/ephemera_field_change_set.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 class EphemeraFieldChangeSet < Valkyrie::ChangeSet
-  validates :name, presence: true
-  property :name, multiple: false
+  validates :field_name, :member_of_vocabulary_id, presence: true
+  property :field_name, multiple: false, required: true
+  property :member_of_vocabulary_id, multiple: false, required: true, type: Valkyrie::Types::ID
 
   def primary_terms
-    [:name]
+    [:field_name, :member_of_vocabulary_id, :append_id]
   end
 end

app/change_sets/ephemera_term_change_set.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+class EphemeraTermChangeSet < Valkyrie::ChangeSet
+  validates :label, :member_of_vocabulary_id, presence: true
+  property :label, multiple: false, required: true
+  property :uri, multiple: false, required: false
+  property :code, multiple: false, required: false
+  property :tgm_label, multiple: false, required: false
+  property :lcsh_label, multiple: false, required: false
+  property :member_of_vocabulary_id, multiple: false, required: true, type: Valkyrie::Types::ID
+
+  def primary_terms
+    [
+      :label,
+      :uri,
+      :code,
+      :tgm_label,
+      :lcsh_label,
+      :member_of_vocabulary_id
+    ]
+  end
+end

app/change_sets/ephemera_vocabulary_change_set.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+class EphemeraVocabularyChangeSet < Valkyrie::ChangeSet
+  validates :label, :value, presence: true
+  property :label, multiple: false, required: true
+  property :value, multiple: false, required: true
+  property :definition, multiple: false, required: false
+  property :member_of_vocabulary_id, multiple: false, required: false, type: Valkyrie::Types::ID
+
+  def primary_terms
+    [:label, :value, :definition, :member_of_vocabulary_id]
+  end
+end

app/controllers/catalog_controller.rb

@@ -39,7 +39,10 @@ def self.search_config
     config.show.partials += [:universal_viewer]
     config.show.partials += [:resource_attributes]
     config.show.partials += [:workflow_controls]
+    config.show.partials += [:vocabulary_nav]
     config.show.partials += [:members]
+    config.show.partials += [:categories]
+    config.show.partials += [:terms]
     config.index.thumbnail_method = :figgy_thumbnail_path
   end
 

app/controllers/ephemera_fields_controller.rb

@@ -8,4 +8,9 @@ class EphemeraFieldsController < ApplicationController
     metadata_adapter: Valkyrie::MetadataAdapter.find(:indexing_persister),
     storage_adapter: Valkyrie.config.storage_adapter
   )
+  before_action :load_vocabularies, only: [:new, :edit]
+
+  def load_vocabularies
+    @vocabularies = query_service.find_all_of_model(model: EphemeraVocabulary).map(&:decorate)
+  end
 end

app/controllers/ephemera_folders_controller.rb

@@ -9,6 +9,7 @@ class EphemeraFoldersController < ApplicationController
     storage_adapter: Valkyrie.config.storage_adapter
   )
   before_action :load_collections, only: [:new, :edit]
+  before_action :load_fields, only: [:new, :edit]
 
   def manifest
     authorize! :manifest, resource
@@ -41,6 +42,31 @@ def load_collections
     @collections = query_service.find_all_of_model(model: Collection).map(&:decorate)
   end
 
+  def ephemera_box
+    @ephemera_box ||= find_resource(params[:parent_id]).decorate
+  rescue => e
+    Rails.logger.warn e
+    nil
+  end
+
+  def fields
+    @fields ||= ephemera_box.ephemera_project.fields
+  rescue => e
+    Rails.logger.warn e
+    []
+  end
+
+  def load_fields
+    fields.each do |field|
+      case field.attribute_name
+      when 'subject'
+        @subject = field.vocabulary.categories
+      else
+        instance_variable_set("@#{field.attribute_name}", field.vocabulary.terms)
+      end
+    end
+  end
+
   def browse_everything_files
     change_set_persister.buffer_into_index do |buffered_changeset_persister|
       change_set.validate(pending_uploads: change_set.pending_uploads + selected_files)

app/controllers/ephemera_terms_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+class EphemeraTermsController < ApplicationController
+  include Valhalla::ResourceController
+  include TokenAuth
+  self.change_set_class = DynamicChangeSet
+  self.resource_class = EphemeraTerm
+  self.change_set_persister = ::PlumChangeSetPersister.new(
+    metadata_adapter: Valkyrie::MetadataAdapter.find(:indexing_persister),
+    storage_adapter: Valkyrie.config.storage_adapter
+  )
+  before_action :load_vocabularies, only: [:new, :edit]
+  before_action :load_terms, only: [:index]
+
+  def index
+    render 'index'
+  end
+
+  def load_vocabularies
+    @vocabularies = query_service.find_all_of_model(model: EphemeraVocabulary).map(&:decorate)
+  end
+
+  def load_terms
+    @terms = query_service.find_all_of_model(model: EphemeraTerm).map(&:decorate)
+  end
+end

app/controllers/ephemera_vocabularies_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+class EphemeraVocabulariesController < ApplicationController
+  include Valhalla::ResourceController
+  include TokenAuth
+  self.change_set_class = DynamicChangeSet
+  self.resource_class = EphemeraVocabulary
+  self.change_set_persister = ::PlumChangeSetPersister.new(
+    metadata_adapter: Valkyrie::MetadataAdapter.find(:indexing_persister),
+    storage_adapter: Valkyrie.config.storage_adapter
+  )
+  before_action :load_vocabularies, only: [:index, :new, :edit]
+
+  def index
+    render 'index'
+  end
+
+  def load_vocabularies
+    @vocabularies = query_service.find_all_of_model(model: EphemeraVocabulary).map(&:decorate)
+  end
+end

app/decorators/ephemera_field_decorator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 class EphemeraFieldDecorator < Valkyrie::ResourceDecorator
-  self.display_attributes = [:name]
+  self.display_attributes = [:rendered_name, :vocabulary]
   delegate :query_service, to: :metadata_adapter
 
   def parents
@@ -15,11 +15,54 @@ def metadata_adapter
     Valkyrie.config.metadata_adapter
   end
 
+  def name_label
+    name_term.blank? ? 'Unnamed' : name_term.label
+  end
+
+  def title
+    name_label
+  end
+
+  def attribute_name
+    name_label.split('.').last
+  end
+
+  def rendered_name
+    field_name.map do |name|
+      term = ControlledVocabulary.for(:ephemera_field).find(name)
+      next unless term
+      h.link_to(term.label, term.value) +
+        h.content_tag("br") +
+        h.content_tag("p") do
+          term.definition.html_safe
+        end
+    end
+  end
+
+  def vocabulary
+    @vocabulary ||=
+      begin
+        query_service.find_references_by(resource: model, property: :member_of_vocabulary_id)
+                     .map(&:decorate)
+                     .to_a.first
+      end
+  end
+
+  def vocabulary_label
+    vocabulary.blank? ? 'Unnassigned' : vocabulary.label
+  end
+
   def manageable_files?
     false
   end
 
   def manageable_structure?
     false
   end
+
+  private
+
+    def name_term
+      @name_term ||= ControlledVocabulary.for(:ephemera_field).find(field_name.first)
+    end
 end

app/decorators/ephemera_term_decorator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+class EphemeraTermDecorator < Valkyrie::ResourceDecorator
+  self.display_attributes = [:label, :uri, :code, :tgm_label, :lcsh_label, :vocabulary]
+  delegate :query_service, to: :metadata_adapter
+
+  def title
+    label
+  end
+
+  def metadata_adapter
+    Valkyrie.config.metadata_adapter
+  end
+
+  def manageable_files?
+    false
+  end
+
+  def manageable_structure?
+    false
+  end
+
+  def vocabulary
+    @vocabulary ||=
+      begin
+        query_service.find_references_by(resource: model, property: :member_of_vocabulary_id)
+                     .select { |r| r.is_a?(EphemeraVocabulary) }
+                     .map(&:decorate)
+                     .to_a.first
+      end
+  end
+end

app/decorators/ephemera_vocabulary_decorator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+class EphemeraVocabularyDecorator < Valkyrie::ResourceDecorator
+  self.display_attributes = [:label, :value, :definition, :categories, :terms]
+  delegate :query_service, to: :metadata_adapter
+
+  def to_s
+    label
+  end
+
+  def title
+    to_s
+  end
+
+  def metadata_adapter
+    Valkyrie.config.metadata_adapter
+  end
+
+  def vocabulary
+    @vocabulary ||=
+      begin
+        query_service.find_references_by(resource: model, property: :member_of_vocabulary_id)
+                     .select { |r| r.is_a?(EphemeraVocabulary) }
+                     .map(&:decorate)
+                     .to_a.first
+      end
+  end
+
+  def vocabulary_label
+    vocabulary.blank? ? 'Unnassigned' : vocabulary.label
+  end
+
+  def find_references
+    @referenced_by ||=
+      begin
+        query_service.find_inverse_references_by(resource: model, property: :member_of_vocabulary_id)
+
+      end
+  end
+
+  def categories
+    @categories ||=
+      find_references.select { |r| r.is_a?(EphemeraVocabulary) }
+                     .map(&:decorate)
+                     .to_a
+  end
+
+  def terms
+    @terms ||=
+      find_references.select { |r| r.is_a?(EphemeraTerm) }
+                     .map(&:decorate)
+                     .to_a
+  end
+
+  def manageable_files?
+    false
+  end
+
+  def manageable_structure?
+    false
+  end
+end

app/models/controlled_vocabulary.rb

@@ -128,4 +128,18 @@ def json
       @json ||= MultiJson.load(Faraday.get(url).body, symbolize_keys: true)
     end
   end
+
+  class EphemeraField < ControlledVocabulary
+    ControlledVocabulary.register(:ephemera_field, self)
+    def self.authority_config
+      @authority_config ||= YAML.safe_load(File.read(Rails.root.join("config", "authorities", "ephemera_field_name.yml")), [Symbol])
+    end
+
+    def all(_scope = nil)
+      @all ||=
+        self.class.authority_config[:terms].map do |term|
+          Term.new(term)
+        end
+    end
+  end
 end

app/models/ephemera_field.rb

@@ -2,5 +2,6 @@
 class EphemeraField < Valhalla::Resource
   include Valkyrie::Resource::AccessControls
   attribute :id, Valkyrie::Types::ID.optional
-  attribute :name, Valkyrie::Types::Set
+  attribute :field_name
+  attribute :member_of_vocabulary_id
 end

app/models/ephemera_term.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+class EphemeraTerm < Valhalla::Resource
+  include Valkyrie::Resource::AccessControls
+  attribute :id, Valkyrie::Types::ID.optional
+  attribute :label, Valkyrie::Types::String
+  attribute :uri, Valkyrie::Types::Any
+  attribute :code, Valkyrie::Types::Any
+  attribute :tgm_label, Valkyrie::Types::Any
+  attribute :lcsh_label, Valkyrie::Types::Any
+  attribute :member_of_vocabulary_id
+end

app/models/ephemera_vocabulary.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+class EphemeraVocabulary < Valhalla::Resource
+  include Valkyrie::Resource::AccessControls
+  attribute :id, Valkyrie::Types::ID.optional
+  attribute :label, Valkyrie::Types::String
+  attribute :value, Valkyrie::Types::Any
+  attribute :definition, Valkyrie::Types::String
+  attribute :member_of_vocabulary_id
+end

app/views/catalog/_admin_controls.html.erb

@@ -23,6 +23,9 @@
 <% end %>
 
   <div class="form-actions">
+    <% if resource.kind_of?(EphemeraTerm) %>
+      <%= link_to "View All Terms", ephemera_terms_path, class: 'btn btn-default' %>
+    <% end %>
     <%= link_to "Edit This #{resource.human_readable_type}", main_app.polymorphic_path([:edit, resource]), class: 'btn btn-default' %>
     <% if decorated_resource.manageable_files? %>
       <%= link_to "File Manager", main_app.polymorphic_path([:file_manager, resource]), class: 'btn btn-default' %>