geoblacklight_admin 0.0.1

data/app/helpers/document_helper.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# DocumentHelper
+module DocumentHelper
+  def publication_state_badge(document)
+    case document.publication_state
+    when "draft"
+      link_to("#document_publication_state") do
+        tag.span("Draft", class: "badge badge-secondary")
+      end
+    when "published"
+      link_to("#document_publication_state") do
+        tag.span("Published", class: "badge badge-success")
+      end
+    when "unpublished"
+      link_to("#document_publication_state") do
+        tag.span("Unpublished", class: "badge badge-danger")
+      end
+    end
+  end
+
+  def localize_link(link)
+    uri = URI.parse(link)
+    "/admin/documents?#{uri.query}"
+  end
+
+  def sort_link(link)
+    link_to link["attributes"]["label"], localize_link(link["links"]["self"]), {class: "dropdown-item"}
+  end
+
+  def link_from_api(link)
+    # Append facet - Full URI returned
+    uri = URI.parse(link["links"]["self"])
+    {action: "add", link: "/admin/documents?#{uri.query}"}
+  rescue
+    # Remove facet - Only path and query returned
+    uri = URI.parse(link["links"]["remove"])
+    {action: "remove", link: "/admin/documents?#{uri.query}"}
+  end
+
+  def previous_link(links)
+    if links["prev"]
+      link_to "Previous", localize_link(links["prev"]), {class: "btn btn-outline-primary btn-sm"}
+    else
+      link_to "Previous", "javascript:;", {class: "btn btn-outline-primary btn-sm disabled", "aria-disabled": true}
+    end
+  end
+
+  def next_link(links)
+    if links["next"]
+      link_to "Next", localize_link(links["next"]), {class: "btn btn-outline-primary btn-sm"}
+    else
+      link_to "Next", "javascript:;", {class: "btn btn-outline-primary btn-sm disabled", "aria-disabled": true}
+    end
+  end
+
+  def blacklight_link(document)
+    "#{BLACKLIGHT_URL}/catalog/#{document.friendlier_id}"
+  end
+end

data/app/helpers/form_input_helper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# We could have done these as methods on a custom local SimpleForm::FormBuilder class?
+# But for now we use ugly ugly helpers, first arg is always form builder.
+#
+# These also could arguably have been done somewhat more readably with template partials
+# (and in some cases may call out to render partials?), but ruby methods are both somewhat
+# more performant (especially in dev mode), and more clear to add parameterization via arguments to
+# (`locals` in partials are confusing and lead to confusing ERB code for defaults etc.)
+#
+# Arguably we should extract some of these to helper classes. Rails does not provide
+# a great architecture for complex view generation code.
+module FormInputHelper
+  # We have a variety of inputs that are a category (with a select input)
+  # followed by a value. They always map to custom AttrJson::Model classes, which
+  # this helper assumes -- and gets that class for reflection from builder.object.class.
+  #
+  # By default the attribute names are assumed to be :category and :value,
+  # but you can pass in others.
+  #
+  # You must pass in valid category db values in category_list. (Future, some
+  # kind of introspection to default maybe)
+  #
+  # There is some translation of values to human-displayable labels, using i18n.
+  # For instance, if your class is Work::ExternalID, attribute is `category`, and one
+  # value is "object_id", you can provide an i18n key at:
+  # `activemodel.enum_values.work/external_id.category.object_id`
+  #
+  # @example
+  #         <%= f.repeatable_attr_input(:external_id) do |sub_form| %>
+  #            <%= category_and_value(sub_form) %>
+  #         <% end %>
+  #
+  # FUTURE:
+  # * Extract to helper object?
+  # * I18n right now doesn't use superclasses, we could use ActiveModel
+  #   human_attribute_name as a guide, and make our own human_value_name or something
+  #   that is more powerful.
+  def category_and_value(builder,
+    category_list:, category_key: :category,
+    value_key: :value,
+    input_data_attributes: {})
+    model_class = builder.object.class
+
+    # If existing value (which may be nil) is not in category list, add it to front.
+    existing_category_value = builder.object.send(category_key)
+    category_list = [existing_category_value] + category_list unless category_list.include?(existing_category_value)
+
+    # Turn category list into values and human labels, using i18n or rails humanizing.
+    category_list = category_list.collect { |key|
+      value = if key.nil?
+        key
+      elsif model_class.respond_to?(:model_name) && key.present?
+        I18n.t(key,
+          scope: "activemodel.enum_values.#{model_class.model_name.i18n_key}.#{category_key}",
+          default: key)
+      else
+        key
+      end
+
+      [value, key]
+    }.to_h
+
+    tag.div(class: "form-row category-and-value") do
+      tag.div(class: "col-left category") {
+        builder.input category_key, collection: category_list, label: false, include_blank: false
+      } +
+        tag.div(class: "col-sm value") {
+          builder.input value_key, label: false, input_html: {data: input_data_attributes}
+        }
+    end
+  end
+end

data/app/helpers/geoblacklight_admin_helper.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# GeoblacklightAdminHelper
+module GeoblacklightAdminHelper
+  # @TODO:
+  # Cannot generate app if uncommented...
+  # Uncomment after app is generated to fix view errors
+  # include ::Pagy::Frontend
+
+  # jbuilder helper
+  def no_json_blanks(value)
+    case value
+    when String
+      value.presence
+    when Array
+      value.join.blank? ? nil : value
+    end
+  end
+
+  # qa (questioning_authoriry) gem oddly gives us no route helpers, so
+  # let's make one ourselves, for it's current mount point, we can change
+  # it if needed but at least it's DRY.
+  def qa_search_vocab_path(vocab, subauthority = nil)
+    path = "/authorities/search/#{CGI.escape vocab}"
+
+    path += "/#{CGI.escape subauthority}" if subauthority
+
+    path
+  end
+
+  def flash_class(level)
+    alerts = {
+      "notice" => "alert alert-info",
+      "success" => "alert alert-success",
+      "error" => "alert alert-error",
+      "alert" => "alert alert-error"
+    }
+    alerts[level]
+  end
+
+  def b1g_institution_codes
+    {
+      "01" => "Indiana University",
+      "02" => "University of Illinois Urbana-Champaign",
+      "03" => "University of Iowa",
+      "04" => "University of Maryland",
+      "05" => "University of Minnesota",
+      "06" => "Michigan State University",
+      "07" => "University of Michigan",
+      "08" => "Purdue University",
+      "09" => "Pennsylvania State University",
+      "10" => "University of Wisconsin-Madison",
+      "11" => "The Ohio State University",
+      "12" => "University of Chicago",
+      "13" => "University of Nebraska-Lincoln",
+      "14" => "Rutgers University-New Brunswick"
+    }
+  end
+
+  def notifications_badge
+    notifications_classes = ["badge"]
+    notifications_classes << "badge-dark" if current_user.notifications.unread.empty?
+    notifications_classes << "badge-danger" if current_user.notifications.unread.size.positive?
+    "<span class='#{notifications_classes.join(" ")}' id='notification-count'>#{current_user.notifications.unread.size}</span>"
+  end
+
+  # From Blacklight::HiddenSearchStateComponent
+  def params_as_hidden_fields(params)
+    hidden_fields = []
+    flatten_hash(params).each do |name, value|
+      value = Array.wrap(value)
+      value.each do |v|
+        hidden_fields << hidden_field_tag(name, v.to_s, id: nil)
+      end
+    end
+
+    safe_join(hidden_fields, "\n")
+  end
+
+  def flatten_hash(hash, ancestor_names = [])
+    flat_hash = {}
+    hash.each do |k, v|
+      names = Array.new(ancestor_names)
+      names << k
+      if v.is_a?(Hash)
+        flat_hash.merge!(flatten_hash(v, names))
+      else
+        key = flat_hash_key(names)
+        key += "[]" if v.is_a?(Array)
+        flat_hash[key] = v
+      end
+    end
+
+    flat_hash
+  end
+
+  def flat_hash_key(names)
+    names = Array.new(names)
+    name = names.shift.to_s.dup
+    names.each do |n|
+      name << "[#{n}]"
+    end
+    name
+  end
+
+  def diff_class(char)
+    case char
+    when "~"
+      "table-warning"
+    when "-"
+      "table-danger"
+    when "+"
+      "table-success"
+    else
+      ""
+    end
+  end
+end

data/app/helpers/import_documents_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# ImportDocumentsHelper
+module ImportDocumentsHelper
+end

data/app/helpers/mappings_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# MappingsHelper
+module MappingsHelper
+  def attribute_collection
+    attrs = Element.importable.map(&:solr_field).sort
+    attrs.prepend("")
+    attrs.prepend("Discard")
+    attrs
+  end
+
+  def mapping_suggestion(import, header)
+    if import.mapping_configuration.include?(header.to_sym)
+      import.mapping_configuration[header.to_sym][:destination]
+    else
+      false
+    end
+  end
+
+  def delimiter_suggestion(import, header)
+    if import.mapping_configuration.include?(header.to_sym)
+      import.mapping_configuration[header.to_sym][:delimited]
+    else
+      false
+    end
+  end
+end

data/app/indexers/document_indexer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Solr indexing for our document class. Still a work in progress.
+class DocumentIndexer < Kithe::Indexer
+  configure do
+    # Kithe
+    to_field "model_pk_ssi", obj_extract("id") # the actual db pk, a UUID
+
+    # GeoBlacklight
+    to_field "gbl_mdVersion_s", literal("Aardvark")
+
+    # to_field 'geomg_id_s', obj_extract('friendlier_id') # the actual db pk, a UUID
+
+    # Define `to_field`(s) via Element
+    Element.indexable.each do |elm|
+      to_field elm.solr_field, obj_extract(elm.index_value)
+    end
+
+    to_field "gbl_mdModified_dt", obj_extract("gbl_mdModified_dt")
+
+    # May want to switch to or add a 'date published' instead, right
+    # now we only have date added to DB, which is what we had in sufia.
+    to_field "date_created_dtsi" do |rec, _acc|
+      rec.created_at.utc.iso8601 if rec&.created_at
+    end
+
+    to_field "date_modified_dtsi" do |rec, _acc|
+      rec.updated_at.utc.iso8601 if rec&.updated_at
+    end
+
+    # - GEOMG
+    to_field "b1g_geom_import_id_ssi", obj_extract("import_id")
+  end
+end

data/app/jobs/bulk_action_revert_document_job.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# BulkActionRevertDocumentJob
+class BulkActionRevertDocumentJob < ApplicationJob
+  queue_as :default
+
+  def perform(action, doc)
+    case action
+    when :revert_publication_status
+      revert_publication_status(doc)
+    when :revert_delete
+      revert_delete(doc)
+    else
+      logger.debug("@TODO - #{field_name} => #{field_value}")
+    end
+  end
+
+  def revert_publication_status(doc)
+    document = Document.find_by!(friendlier_id: doc.friendlier_id)
+
+    logger.debug("Revert PubStatus - #{document.friendlier_id}")
+
+    versions = document.versions
+    document = versions[doc.version].reify
+    document.skip_callbacks = true
+
+    if document.save
+      doc.state_machine.transition_to!(:success)
+    else
+      doc.state_machine.transition_to!(:failed)
+    end
+  end
+
+  def revert_delete(doc)
+    document = Document.new(id: doc.document_id)
+
+    logger.debug("Revert Delete - #{document.id}")
+
+    versions = document.versions
+    document = versions.last.reify
+    document.skip_callbacks = true
+
+    if document.save
+      doc.state_machine.transition_to!(:success)
+    else
+      doc.state_machine.transition_to!(:failed)
+    end
+  end
+end

data/app/jobs/bulk_action_revert_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# BulkActionRevertJob
+class BulkActionRevertJob < ApplicationJob
+  queue_as :default
+
+  def perform(bulk_action)
+    action = case bulk_action.field_name
+    when "Publication State"
+      logger.debug("BulkAction: Revert Publication Status")
+      :revert_publication_status
+    when "Delete"
+      logger.debug("BulkAction: Revert Delete")
+      :revert_delete
+    else
+      logger.debug("BulkAction: Revert Field Value")
+      :revert_field_value
+    end
+
+    bulk_action.documents.each do |doc|
+      BulkActionRevertDocumentJob.perform_later(action, doc)
+      doc.state_machine.transition_to!(:queued)
+    end
+  end
+end

data/app/jobs/bulk_action_run_document_job.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# BulkActionRunDocumentJob
+class BulkActionRunDocumentJob < ApplicationJob
+  queue_as :default
+
+  def perform(action, doc, field_name, field_value)
+    case action
+    when :update_publication_status
+      update_publication_status(doc, field_value)
+    when :update_delete
+      update_delete(doc, field_value)
+    # @TODO: Field Level changes
+    else
+      logger.debug("@TODO - #{field_name} => #{field_value}")
+    end
+  end
+
+  def update_publication_status(doc, field_value)
+    document = Document.find_by!(friendlier_id: doc.friendlier_id)
+
+    logger.debug("Update PubStatus - #{document.friendlier_id} => #{field_value}")
+
+    if document.update!(publication_state: field_value.to_sym)
+      doc.state_machine.transition_to!(:success)
+    else
+      doc.state_machine.transition_to!(:failed)
+    end
+  end
+
+  def update_delete(doc, field_value)
+    document = Document.find_by!(friendlier_id: doc.friendlier_id)
+
+    logger.debug("Update Delete - #{document.friendlier_id} => #{field_value}")
+
+    if document.destroy
+      doc.state_machine.transition_to!(:success)
+    else
+      doc.state_machine.transition_to!(:failed)
+    end
+  end
+end

data/app/jobs/bulk_action_run_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# BulkActionRunJob
+class BulkActionRunJob < ApplicationJob
+  queue_as :default
+
+  def perform(bulk_action)
+    action = case bulk_action.field_name
+    when "Publication State"
+      logger.debug("BulkAction: Update Publication Status")
+      :update_publication_status
+    when "Delete"
+      logger.debug("BulkAction: Delete")
+      :update_delete
+    else
+      :update_field_value
+    end
+
+    bulk_action.documents.each do |doc|
+      BulkActionRunDocumentJob.perform_later(action, doc, bulk_action.field_name, bulk_action.field_value)
+      doc.state_machine.transition_to!(:queued)
+    end
+
+    # Capture State
+    bulk_action.state_machine.transition_to!(:queued)
+  end
+end

data/app/jobs/export_job.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "csv"
+
+# ExportJob
+class ExportJob < ApplicationJob
+  queue_as :default
+
+  def perform(current_user, query_params, export_service)
+    logger.debug("\n\n Background Job: ♞")
+    logger.debug("User: #{current_user.inspect}")
+    logger.debug("Query: #{query_params.inspect}")
+    logger.debug("Export Service: #{export_service.inspect}")
+    logger.debug("\n\n")
+
+    # Test broadcast
+    ActionCable.server.broadcast("export_channel", {data: "Hello from Export Job!"})
+
+    # Query params into Doc ids
+    document_ids = query_params[:ids] || crawl_query(query_params)
+
+    logger.debug("Document Ids: #{document_ids}")
+
+    # Send progress
+    file_content = export_service.call(document_ids)
+
+    # Write into tempfile
+    @tempfile = Tempfile.new(["export-#{Time.zone.today}", ".csv"]).tap do |file|
+      CSV.open(file, "wb") do |csv|
+        file_content.each do |row|
+          csv << row
+        end
+      end
+    end
+
+    # Create notification
+    # Message: "Download Type|Row Count|Button Label"
+    notification = ExportNotification.with(message: "CSV (#{export_service.short_name})|#{ActionController::Base.helpers.number_with_delimiter(file_content.size - 1)} rows|CSV")
+
+    # Deliver notification
+    notification.deliver(current_user)
+
+    # Attach CSV file (can only attach after persisted)
+    notification.record.file.attach(io: @tempfile, filename: "geomg-export-#{Time.zone.today}.csv", content_type: "text/csv")
+
+    # Update UI
+    ActionCable.server.broadcast("export_channel", {
+      data: "Notification ready!",
+      actions: [
+        {
+          method: "RefreshNotifications",
+          payload: current_user.notifications.unread.count
+        }
+      ]
+    })
+  end
+
+  def crawl_query(query_params, doc_ids = [])
+    logger.debug("\n\n CRAWL Query: #{query_params}")
+    api_results = BlacklightApiIds.new(query_params)
+    logger.debug("API Results: #{api_results.results.inspect}")
+
+    doc_ids << api_results.results.pluck("id")
+
+    unless api_results.meta["pages"]["next_page"].nil?
+      crawl_query(query_params.merge!({page: api_results.meta["pages"]["next_page"]}),
+        doc_ids)
+    end
+
+    doc_ids
+  end
+end

data/app/jobs/export_json_job.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+# ExportJob
+class ExportJsonJob < ApplicationJob
+  queue_as :default
+
+  def perform(current_user, query_params, export_service)
+    Rails.logger.debug("\n\n Background Job: ♞")
+    Rails.logger.debug { "User: #{current_user.inspect}" }
+    Rails.logger.debug { "Query: #{query_params.inspect}" }
+    Rails.logger.debug { "Export Service: #{export_service.inspect}" }
+    Rails.logger.debug("\n\n")
+
+    # Test broadcast
+    ActionCable.server.broadcast("export_channel", {data: "Hello from Export JSON Job!"})
+
+    # Query params into Doc ids
+    document_ids = query_params[:ids] || crawl_query(query_params)
+
+    # Rails.logger.debug("Document Ids: #{document_ids}")
+
+    # Send progress
+    documents = export_service.call(document_ids)
+
+    # Write files into tempdir, zip together
+    FileUtils.mkdir_p("ogm")
+
+    Dir.mktmpdir do |dir|
+      documents.each do |doc|
+        # ===== Final Directory Structure =====
+        # => Zip
+        # ==> Provider
+        # ===> Resource class (first)
+        # ====> id.json
+
+        Rails.logger.debug { "==== Query Format #{query_params[:format]} ====" }
+        Rails.logger.debug { "==== Writing - #{doc.friendlier_id} - #{query_params[:format]} ====" }
+
+        begin
+          # File Path
+          code = doc.b1g_code_s.presence || "_b1g_code_s_missing"
+          resource_class = doc.gbl_resourceClass_sm.present? ? doc.gbl_resourceClass_sm.first : "_gbl_resourceClass_sm_missing"
+          tree = Pathname("#{dir}/#{resource_class}/#{code}/#{doc.friendlier_id}.json")
+          tree.dirname.mkpath
+          Rails.logger.debug tree.inspect
+
+          json_output = DocumentsController.render("_#{query_params[:format]}",
+            locals: {document: doc})
+
+          json_obj = JSON.parse(json_output)
+          Rails.logger.debug json_obj
+
+          # Remove nil/null values from JSON
+          json_obj.compact!
+
+          tree.write(JSON.pretty_generate(json_obj))
+        rescue NoMethodError => e
+          Rails.logger.debug { "==== Error! - #{doc.friendlier_id} ====" }
+          Rails.logger.debug e.inspect
+          next
+        end
+      end
+
+      # ===== Local debugging =====
+      # Sanity check dir
+      # Rails.logger.debug '==== Dir GLOB - START ===='
+      # Rails.logger.debug Dir.glob("#{dir}/*")
+      # Rails.logger.debug '==== Dir GLOB - END ===='
+
+      # Zip dir and attach
+      @zip_file = Rails.root.join("tmp", "export-json-#{Time.zone.today}-#{SecureRandom.hex(8)}.zip")
+      zf = ZipFileGenerator.new(dir, @zip_file)
+      zf.write
+
+      Rails.logger.debug { "File size: #{@zip_file.size}" }
+    end
+
+    # Create notification
+    # Message: "Download Type|Row Count|Button Label"
+    notification = ExportNotification.with(message: "#{query_params[:format].humanize.upcase}|#{ActionController::Base.helpers.number_with_delimiter(documents.size)} rows|ZIP")
+
+    # Deliver notification
+    notification.deliver(current_user)
+
+    # Attach CSV file (can only attach after persisted)
+    notification.record.file.attach(io: File.open(@zip_file), filename: "geomg-export-#{Time.zone.today}.zip",
+      content_type: "application/zip")
+
+    Rails.logger.debug "Notification File attached!"
+
+    # Update UI
+    ActionCable.server.broadcast("export_channel", {
+      data: "Notification ready!",
+      actions: [
+        {
+          method: "RefreshNotifications",
+          payload: current_user.notifications.unread.count
+        }
+      ]
+    })
+  end
+
+  def crawl_query(query_params, doc_ids = [])
+    logger.debug("\n\n CRAWL Query: #{query_params}")
+    api_results = BlacklightApiIds.new(query_params)
+    logger.debug("API Results: #{api_results.results.inspect}")
+
+    doc_ids << api_results.results.pluck("id")
+
+    unless api_results.meta["pages"]["next_page"].nil?
+      crawl_query(query_params.merge!({page: api_results.meta["pages"]["next_page"]}),
+        doc_ids)
+    end
+
+    doc_ids
+  end
+end

data/app/jobs/import_document_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# ImportDocumentJob class
+class ImportDocumentJob < ApplicationJob
+  queue_as :default
+
+  def perform(import_document)
+    # @TODO: Check for friendlier_id or raise error
+    document = Document.where(
+      friendlier_id: import_document.friendlier_id
+    ).first_or_create
+
+    # Set the geom
+    document.set_geometry
+
+    if document.update(import_document.to_hash)
+      import_document.state_machine.transition_to!(:success)
+    else
+      import_document.state_machine.transition_to!(:failed, "Failed - #{document.errors.inspect}")
+    end
+  rescue => e
+    logger.debug("Error: #{e}")
+    import_document.state_machine.transition_to!(:failed, "Error - #{e.inspect}")
+  end
+end