geoblacklight_admin 0.0.1

data/app/models/import/csv_duplicates_validator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "csv"
+
+# CSV Duplicates Validator
+#
+# * Checks the CSV file for duplicate IDs.
+# * Fails import if duplicate ID is found.
+#
+class Import
+  # CsvDuplicatesValidator
+  class CsvDuplicatesValidator < ActiveModel::Validator
+    def validate(record)
+      valid_csv_file = true
+      duplicate_id = validate_csv_file(record.csv_file)
+      unless duplicate_id.nil?
+        valid_csv_file = false
+        record.errors.add(:csv_file, "Duplicate ID value found: #{duplicate_id}. Please clean up the CSV file and reimport.")
+      end
+
+      valid_csv_file
+    end
+
+    def validate_csv_file(csv_file)
+      ids = Set.new
+      duplicate_id = nil
+      csv = CSV.parse(csv_file.download, headers: true)
+
+      csv["ID"].each do |id|
+        duplicate_id = id unless ids.add?(id)
+      end
+
+      duplicate_id
+    end
+  end
+end

data/app/models/import/csv_header_validator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "csv"
+
+# CSV Header Validation
+class Import
+  # CsvHeaderValidator
+  class CsvHeaderValidator < ActiveModel::Validator
+    def validate(record)
+      valid_csv_header = true
+      unless valid_csv_headers?(record.csv_file)
+        valid_csv_header = false
+        record.errors.add(:csv_file, "Missing a required CSV header. Title, Resource Class, Access Rights, and ID are required.")
+      end
+
+      valid_csv_header
+    end
+
+    def valid_csv_headers?(csv_file)
+      headers = CSV.parse(csv_file.download)[0]
+      (["Title", "Resource Class", "Access Rights", "ID"] - headers).empty?
+    end
+  end
+end

data/app/models/import.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "csv"
+
+# Import class
+class Import < ApplicationRecord
+  include ActiveModel::Validations
+
+  # Callbacks (keep at top)
+  after_commit :set_csv_file_attributes, if: :persisted?
+  after_commit :check_if_mapped, if: :persisted?
+
+  # Associations
+  has_one_attached :csv_file
+  has_many :documents
+  has_many :import_documents, dependent: :destroy
+  has_many :import_transitions, autosave: false, dependent: :destroy
+  has_many :mappings, -> { order(:id) }, dependent: :destroy, inverse_of: :import
+  accepts_nested_attributes_for :mappings
+
+  # Validations
+  validates :name, :type, presence: true
+  validates :csv_file, attached: true, content_type: {in: "text/csv", message: "is not a CSV file"}
+
+  validates_with Import::CsvHeaderValidator
+  validates_with Import::CsvDuplicatesValidator
+
+  # States
+  include Statesman::Adapters::ActiveRecordQueries[
+    transition_class: ImportTransition,
+    initial_state: :created
+  ]
+
+  def state_machine
+    @state_machine ||= ImportStateMachine.new(self, transition_class: ImportTransition)
+  end
+
+  def set_csv_file_attributes
+    parsed = CSV.parse(csv_file.download)
+
+    update_columns(
+      headers: parsed[0],
+      row_count: parsed.size - 1,
+      content_type: csv_file.content_type.to_s,
+      filename: csv_file.filename.to_s,
+      extension: csv_file.filename.extension.to_s
+    )
+  end
+
+  def check_if_mapped
+    state_machine.transition_to!(:mapped) if mappings_valid? && state_machine.can_transition_to?(:mapped)
+  end
+
+  def all_mapping_keys
+    database = mappings.collect(&:destination_field)
+    default = default_mappings.collect(&:keys)
+    assumed = assumed_mappings.collect(&:values)
+
+    mappings = (database + default + assumed).flatten
+    mappings.map(&:to_s)
+  end
+
+  def mappings_valid?
+    (GEOMG_SCHEMA[:required] - all_mapping_keys.uniq).empty?
+  end
+
+  def run!
+    # @TODO: guard this call, unless mappings_valid?
+
+    # Queue Job
+    ImportRunJob.perform_later(self)
+
+    # Capture State
+    state_machine.transition_to!(:imported)
+    save
+  end
+
+  def convert_data(extract_hash)
+    converted_data = transform_extract(extract_hash)
+    converted_data = append_default_mappings(converted_data)
+    converted_data = append_assumed_mappings(converted_data)
+    converted_data = append_derived_mappings(converted_data)
+    append_required_mappings(converted_data)
+  end
+
+  private
+
+  def create_import_document(kithe_document)
+  end
+
+  def transform_extract(extract_hash)
+    transformed_data = {}
+    mappings.each do |mapping|
+      # logger.debug("Mapping: #{mapping.source_header} to #{mapping.destination_field}")
+
+      # Handle discards
+      if mapping.destination_field == "Discard"
+        next
+      end
+
+      # Handle repeatable dct_references_s entries
+      if mapping.destination_field == "dct_references_s"
+        transformed_data[mapping.destination_field] ||= []
+        if extract_hash[mapping.source_header].present?
+          transformed_data[mapping.destination_field] << {
+            category: GeoblacklightAdmin::Schema.instance.dct_references_mappings[mapping.source_header.to_sym],
+            value: extract_hash[mapping.source_header]
+          }
+        end
+      # Handle solr_geom transformation
+      elsif mapping.destination_field == "solr_geom"
+        transformed_data[mapping.destination_field] = solr_geom_mapping(extract_hash[mapping.source_header])
+
+      # Lastly, set existing values
+      else
+        transformed_data[mapping.destination_field] = extract_hash[mapping.source_header]
+      end
+
+      # Split delimited field values, if field has a value present
+      if mapping.delimited?
+        transformed_data[mapping.destination_field] = transformed_data[mapping.destination_field].present? ? transformed_data[mapping.destination_field].split(klass_delimiter) : ""
+      end
+    end
+
+    transformed_data
+  end
+
+  # Merges an array of hashes into the data hash
+  def append_default_mappings(data_hash)
+    default_mappings.each do |mapping|
+      data_hash.merge!(mapping.stringify_keys)
+    end
+
+    data_hash
+  end
+
+  # Merges copied value hashes into the data hash
+  def append_assumed_mappings(data_hash)
+    assumed_mappings.each do |mapping|
+      mapping.each do |key, value|
+        assumed_mapping = {}
+        assumed_mapping[value] = data_hash[key.to_s]
+        data_hash.merge!(assumed_mapping)
+      end
+    end
+
+    data_hash
+  end
+
+  # Merges derived value hashes into the data hash
+  # Takes value from data hash, manipulates it, stores in new hash entry
+  #
+  # Ex. solr_geom is used to calc the b1g_centroid_ss value
+  def append_derived_mappings(data_hash)
+    derived_mappings.each do |mapping|
+      mapping.each do |key, value|
+        derived_mapping = {}
+
+        args = {data_hash: data_hash.dup, field: value[:field]}
+        derived_mapping[key] = send(value[:method], args)
+
+        data_hash.merge!(derived_mapping.stringify_keys)
+      end
+    end
+
+    data_hash
+  end
+
+  # Ensures required values are in the data hash
+  #
+  # ex. b1g_status_s is required.
+  def append_required_mappings(data_hash)
+    required_mappings.each do |mapping|
+      mapping.each do |key, value|
+        required_mapping = {}
+        required_mapping[key] = value
+
+        unless data_hash.has_key?(key)
+          data_hash.merge!(required_mapping.stringify_keys)
+        end
+      end
+    end
+
+    data_hash
+  end
+end

data/app/models/import_btaa.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Import BTAA
+class ImportBtaa < Import
+  # validations, constants and methods
+
+  def mapping_configuration
+    GeoblacklightAdmin::Schema.instance.importable_fields
+  end
+
+  def klass_delimiter
+    "|"
+  end
+
+  # Solr Field => Hard Value
+  def default_mappings
+    [
+      {gbl_mdVersion_s: "Aardvark"}
+    ]
+  end
+
+  # Copy Value from Field to Field
+  def assumed_mappings
+    # No longer assuming identfier == slug
+    # [
+    #   { 'dc_identifier_s': 'layer_slug_s' }
+    # ]
+    # Return empty array
+    []
+  end
+
+  # Derived Values
+  def derived_mappings
+    [
+      {
+        dcat_centroid:
+          {
+            field: "dcat_bbox",
+            method: "derive_dcat_centroid"
+          }
+      },
+      {
+        b1g_child_record_b:
+          {
+            field: "b1g_child_record_b",
+            method: "derive_boolean"
+          }
+      },
+      {
+        gbl_georeferenced_b:
+          {
+            field: "gbl_georeferenced_b",
+            method: "derive_boolean"
+          }
+      },
+      {
+        gbl_suppressed_b:
+          {
+            field: "gbl_suppressed_b",
+            method: "derive_boolean"
+          }
+      }
+    ]
+  end
+
+  # Required Values
+  # Key / Default Value
+  # Example: { b1g_status_s: 'Active' }
+  def required_mappings
+    []
+  end
+
+  def derive_dcat_centroid(args)
+    data_hash = args[:data_hash]
+    field = args[:field]
+
+    return if data_hash[field].blank?
+
+    w, s, e, n = data_hash[field].split(",")
+    "#{(n.to_f + s.to_f) / 2},#{(e.to_f + w.to_f) / 2}"
+  end
+
+  def derive_boolean(args)
+    data_hash = args[:data_hash]
+    field = args[:field]
+
+    return false if data_hash[field].blank?
+
+    ActiveModel::Type::Boolean.new.cast(data_hash[field].downcase)
+  end
+end

data/app/models/import_btaa_aardvark.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Import GBLv1
+class ImportBtaaAardvark < Import
+  # validations, constants and methods
+
+  def mapping_configuration
+    Geomg.field_mappings_btaa_aardvark
+  end
+
+  def klass_delimiter
+    "|"
+  end
+
+  # Solr Field => Hard Value
+  def default_mappings
+    [
+      {gbl_mdVersion_s: "Aardvark"}
+    ]
+  end
+
+  # Copy Value from Field to Field
+  def assumed_mappings
+    # No longer assuming identfier == slug
+    # [
+    #   { 'dc_identifier_s': 'layer_slug_s' }
+    # ]
+    # Return empty array
+    []
+  end
+
+  # Derived Values
+  def derived_mappings
+    [
+      {dct_references_s:
+        {
+          field: "dct_references_s",
+          method: "geomg_dct_references_s"
+        }},
+      {gbl_dateRange_drsim:
+        {
+          field: "gbl_dateRange_drsim",
+          method: "geomg_b1g_date_range_drsim"
+        }},
+      {locn_geometry:
+        {
+          field: "locn_geometry",
+          method: "solr_geom_mapping"
+        }}
+    ]
+  end
+
+  # Required Values
+  # Key / Default Value
+  def required_mappings
+    [
+      {b1g_status_s: "Active"}
+    ]
+  end
+
+  def solr_geom_mapping(args)
+    data_hash = args[:data_hash]
+    field = args[:field]
+
+    # Example: "ENVELOPE(-87\\, -85.76\\, 39.78\\, 37.96)"
+    geom = data_hash[field]
+    if geom.present?
+      geom = geom&.delete("ENVELOPE(")
+      geom = geom&.delete(")")
+      geom = geom&.delete("\\")
+      w, e, n, s = geom.split(",")
+      "#{w},#{s},#{e},#{n}"
+    else
+      ""
+    end
+  end
+
+  def geomg_b1g_date_range_drsim(args)
+    data_hash = args[:data_hash]
+    field = args[:field]
+
+    # Ex. [2020 TO 2020], [* TO 2020], [2020 TO *]
+    date_range = nil
+    date_range = data_hash[field][0] unless data_hash[field].empty?
+    date_range = date_range[1..12]&.gsub(" TO ", "-") unless date_range.nil?
+    date_range
+  end
+
+  def geomg_dct_references_s(args)
+    data_hash = args[:data_hash]
+    field = args[:field]
+    references = []
+
+    unless data_hash[field].empty?
+      dct_references = data_hash[field][0]
+      json_data = JSON.parse(dct_references[:value])
+
+      json_data.each do |key, value|
+        reference = {
+          value: value,
+          category: Geomg.uri_2_category_references_mappings[key]
+        }
+        references << reference
+      end
+    end
+
+    references
+  end
+end

data/app/models/import_document.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# ImportDocument class
+class ImportDocument < ApplicationRecord
+  has_many :import_document_transitions, autosave: false, dependent: :destroy
+
+  include Statesman::Adapters::ActiveRecordQueries[
+    transition_class: ImportDocumentTransition,
+    initial_state: :queued
+  ]
+
+  def state_machine
+    @state_machine ||= ImportDocumentStateMachine.new(self, transition_class: ImportDocumentTransition)
+  end
+
+  def to_hash
+    {
+      friendlier_id: friendlier_id,
+      title: title,
+      json_attributes: nullify_empty_json_attributes,
+      import_id: import_id
+    }
+  end
+
+  def nullify_empty_json_attributes
+    clean_hash = {}
+
+    json_attributes.each do |key, value|
+      clean_hash[key] = value.present? ? value : nil
+    end
+
+    clean_hash
+  end
+end

data/app/models/import_document_state_machine.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# ImportDocument Statesman
+class ImportDocumentStateMachine
+  include Statesman::Machine
+
+  state :queued, initial: true
+  state :success
+  state :failed
+
+  transition from: :queued, to: %i[success failed]
+end

data/app/models/import_document_transition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Add ImportDocument Statesman Transitions
+class ImportDocumentTransition < ApplicationRecord
+  include Statesman::Adapters::ActiveRecordTransition
+
+  belongs_to :import_document, inverse_of: :import_document_transitions
+
+  after_destroy :update_most_recent, if: :most_recent?
+
+  private
+
+  def update_most_recent
+    last_transition = import_document.import_document_transitions.order(:sort_key).last
+    return if last_transition.blank?
+
+    last_transition.update_column(:most_recent, true)
+  end
+end

data/app/models/import_gblv1.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Import GBLv1
+class ImportGblv1 < Import
+  # validations, constants and methods
+
+  def mapping_configuration
+    Geomg.field_mappings_gblv1
+  end
+
+  def klass_delimiter
+    "|"
+  end
+
+  # Solr Field => Hard Value
+  def default_mappings
+    [
+      {geoblacklight_version: "1.0"}
+    ]
+  end
+
+  # Copy Value from Field to Field
+  def assumed_mappings
+    # No longer assuming identfier == slug
+    # [
+    #   { 'dc_identifier_s': 'layer_slug_s' }
+    # ]
+    # Return empty array
+    []
+  end
+
+  # Derived Values
+  def derived_mappings
+    [
+      {dct_references_s:
+        {
+          field: "dct_references_s",
+          method: "geomg_dct_references_s"
+        }},
+      {b1g_date_range_drsim:
+        {
+          field: "b1g_date_range_drsim",
+          method: "geomg_b1g_date_range_drsim"
+        }}
+    ]
+  end
+
+  # Required Values
+  # Key / Default Value
+  def required_mappings
+    [
+      {b1g_status_s: "Active"}
+    ]
+  end
+
+  def solr_geom_mapping(geom)
+    # Example: "ENVELOPE(-87\\, -85.76\\, 39.78\\, 37.96)"
+    geom&.delete("\\")
+  end
+
+  def geomg_b1g_date_range_drsim(args)
+    data_hash = args[:data_hash]
+    field = args[:field]
+
+    # Ex. [2020 TO 2020], [* TO 2020], [2020 TO *]
+    date_range = nil
+    date_range = data_hash[field][0] unless data_hash[field].empty?
+    date_range = date_range[1..12]&.gsub(" TO ", "-") unless date_range.nil?
+    date_range
+  end
+
+  def geomg_dct_references_s(args)
+    data_hash = args[:data_hash]
+    field = args[:field]
+    references = []
+
+    unless data_hash[field].empty?
+      dct_references = data_hash[field][0]
+      json_data = JSON.parse(dct_references[:value])
+
+      json_data.each do |key, value|
+        reference = {
+          value: value,
+          category: Geomg::FieldMappingsGblv1.uri_2_category_references_mappings[key]
+        }
+        references << reference
+      end
+    end
+
+    references
+  end
+end

data/app/models/import_state_machine.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Import Statesman
+class ImportStateMachine
+  include Statesman::Machine
+
+  state :created, initial: true
+  state :mapped
+  state :imported
+  state :success
+  state :failed
+
+  transition from: :created, to: [:mapped]
+  transition from: :mapped, to: [:imported]
+  transition from: :imported, to: %i[success failed]
+end

data/app/models/import_transition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Add Import Statesman Transitions
+class ImportTransition < ApplicationRecord
+  include Statesman::Adapters::ActiveRecordTransition
+
+  # If your transition table doesn't have the default `updated_at` timestamp column,
+  # you'll need to configure the `updated_timestamp_column` option, setting it to
+  # another column name (e.g. `:updated_on`) or `nil`.
+  #
+  # self.updated_timestamp_column = :updated_on
+  # self.updated_timestamp_column = nil
+
+  belongs_to :import, inverse_of: :import_transitions
+
+  after_destroy :update_most_recent, if: :most_recent?
+
+  private
+
+  def update_most_recent
+    last_transition = import.import_transitions.order(:sort_key).last
+    return if last_transition.blank?
+
+    last_transition.update_column(:most_recent, true)
+  end
+end

data/app/models/mapping.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Mapping
+class Mapping < ApplicationRecord
+  belongs_to :import
+
+  # Validations
+  validates :source_header, presence: true
+  validates :destination_field, presence: true
+end

data/app/models/notification.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Notification
+class Notification < ApplicationRecord
+  include Noticed::Model
+  belongs_to :recipient, polymorphic: true
+
+  has_one_attached :file
+end

data/app/models/user.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# User
+class User < ApplicationRecord
+  include Blacklight::User
+  
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
+  devise :invitable, :database_authenticatable,
+    :recoverable, :rememberable, :validatable
+
+  has_many :bookmarks, dependent: :destroy, as: :user
+  has_many :notifications, dependent: :destroy, as: :recipient
+
+  def bookmarks_for_documents(documents = [])
+    if documents.any?
+      bookmarks.where(document_type: documents.first.class.base_class.to_s, document_id: documents.map(&:id))
+    else
+      []
+    end
+  end
+
+  def document_is_bookmarked?(document)
+    bookmarks_for_documents([document]).any?
+  end
+end