geoblacklight_admin 0.0.1

data/app/models/document/date_range_validator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Date Range Validation
+#
+# Allow: YYYY-YYYY, *-YYYY, YYYY-*, Start YYYY == End YYYY
+# Disallow: YYYX-YYYY, YYYY-, 2000-1999, YYYY-YYYY?
+class Document
+  # DateRangeValidator
+  class DateRangeValidator < ActiveModel::Validator
+    def validate(record)
+      valid_date_ranges = true
+      record.send(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range]).each do |date_range|
+        # Empty is fine
+        if date_range.blank?
+          valid_date_ranges = true
+          return valid_date_ranges
+        end
+
+        # Must split into two via '-'
+        if date_range.split("-").size != 2
+          record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range], "invalid date range present - missing YYYY-YYYY value")
+          valid_date_ranges = false
+          return valid_date_ranges
+        end
+
+        start_date, end_date = date_range.split("-")
+
+        unless valid_yyyy(start_date)
+          record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range], "invalid start date - bad YYYY-YYYY value, only integers or the wildcard '*' allowed")
+          valid_date_ranges = false
+        end
+
+        unless valid_yyyy(end_date)
+          record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range], "invalid end date - bad YYYY-YYYY value, only integers or the wildcard '*' allowed")
+          valid_date_ranges = false
+        end
+
+        # Allow only 1 wildcard
+        if start_date == "*" && end_date == "*"
+          record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range], "invalid only one wildcard can be used")
+          valid_date_ranges = false
+        end
+
+        # Avoid 1996-1946
+        if start_date[/\d+/] && end_date[/\d+/]
+          unless start_date.to_i <= end_date.to_i
+            record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range], "invalid start date must be less than the end date")
+            valid_date_ranges = false
+          end
+        end
+      end
+      valid_date_ranges
+    end
+
+    def valid_yyyy(date)
+      if date[/\D/]
+        return false unless date == "*"
+      else
+        true
+      end
+    end
+  end
+end

data/app/models/document/geom_validator.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "rgeo"
+
+# GEOM Validation
+#
+# Uses local logic to parse and validate ENVELOPE values
+# Uses RGeo to parse and validate POLYGON or MULTIPOLYGON values
+class Document
+  # GeomValidator
+  class GeomValidator < ActiveModel::Validator
+    def validate(record)
+      # Assume true for empty values
+      valid_geom = true
+
+      if record.send(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry]).present?
+        valid_geom = if record.send(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry]).start_with?("ENVELOPE")
+          # Sane ENVELOPE?
+          proper_envelope(record)
+        else
+          # Sane GEOM?
+          proper_geom(record)
+        end
+      end
+
+      valid_geom
+    end
+
+    # Validates ENVELOPE
+    def proper_envelope(record)
+      geom = record.send(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry])
+      begin
+        valid_geom, error_message = valid_envelope?(geom.delete("ENVELOPE()"))
+      rescue => e
+        valid_geom = false
+        record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry], "Invalid envelope: #{e}")
+      end
+
+      unless valid_geom
+        record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry], "Invalid envelope: #{error_message}")
+      end
+
+      valid_geom
+    end
+
+    # Validates POLYGON and MULTIPOLYGON
+    def proper_geom(record)
+      geom = record.send(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry])
+      begin
+        valid_geom = if RGeo::Cartesian::Factory.new.parse_wkt(geom)
+          true
+        else
+          false
+        end
+      rescue => e
+        valid_geom = false
+        record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry], "Invalid geometry: #{e}")
+      end
+
+      # Guard against a whole world polygons
+      if geom == "POLYGON((-180 90, 180 90, 180 -90, -180 -90, -180 90))"
+        valid_geom = false
+        record.errors.add(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry], "Invalid polygon: all points are coplanar input, Solr will not index")
+      end
+
+      valid_geom
+    end
+
+    def valid_envelope?(envelope)
+      # Default to true
+      valid_envelope = true
+      error_message = ""
+
+      # Min/Max - W,E,N,S
+      # ENVELOPE(-180,180,90,-90)
+      min_max = [-180.0, 180.0, 90.0, -90.0]
+      envelope = envelope.split(",")
+
+      # Reject ENVELOPE(-118.00.0000,-88.00.0000,51.00.0000,42.00.0000)
+      # - Double period float-ish things?
+      envelope.each do |val|
+        if val.count(".") >= 2
+          valid_envelope = false
+          error_message = "invalid ENVELOPE(W,E,N,S) syntax - found multiple periods in coordinate value(s)."
+        end
+      end
+
+      # @TODO: Essentially duplicated logic from bbox_validator.rb, DRY it up
+      if envelope.size != 4
+        valid_envelope = false
+        error_message = "invalid ENVELOPE(W,E,N,S) syntax"
+      # W
+      elsif envelope[0].to_f < min_max[0]
+        valid_envelope = false
+        error_message = "invalid minX present"
+      # E
+      elsif envelope[1].to_f > min_max[1]
+        valid_envelope = false
+        error_message = "invalid maX present"
+      # N
+      elsif envelope[2].to_f > min_max[2]
+        valid_envelope = false
+        error_message = "invalid maxY present"
+      # S
+      elsif envelope[3].to_f < min_max[3]
+        valid_envelope = false
+        error_message = "invalid minY present"
+      # Solr - maxY must be >= minY
+      elsif envelope[3].to_f >= envelope[2].to_f
+        valid_envelope = false
+        error_message = "maxY must be >= minY"
+      end
+
+      [valid_envelope, error_message]
+    end
+  end
+end

data/app/models/document/reference.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# Document
+class Document
+  # Reference
+  class Reference
+    # Via GBL Wiki
+    # https://github.com/geoblacklight/geoblacklight/wiki/External-references
+    REFERENCE_VALUES = {
+      wcs: {
+        label: "Web Coverage Service (WCS)",
+        uri: "http://www.opengis.net/def/serviceType/ogc/wcs"
+      },
+      wms: {
+        label: "Web Mapping Service (WMS)",
+        uri: "http://www.opengis.net/def/serviceType/ogc/wms"
+      },
+      wfs: {
+        label: "Web Feature Service (WFS)",
+        uri: "http://www.opengis.net/def/serviceType/ogc/wfs"
+      },
+      iiif_image: {
+        label: "IIIF Image API",
+        uri: "http://iiif.io/api/image"
+      },
+      iiif_manifest: {
+        label: "IIIF Manifest",
+        uri: "http://iiif.io/api/presentation#manifest"
+      },
+      image: {
+        label: "Image file",
+        uri: "http://schema.org/image"
+      },
+      download: {
+        label: "Direct download file",
+        uri: "http://schema.org/downloadUrl"
+      },
+      thumbnail: {
+        label: "Thumbnail file",
+        uri: "http://schema.org/thumbnailUrl"
+      },
+      documentation_download: {
+        label: "Data dictionary / documentation download",
+        uri: "http://lccn.loc.gov/sh85035852"
+      },
+      documentation_external: {
+        label: "Full layer description",
+        uri: "http://schema.org/url"
+      },
+      metadata_iso: {
+        label: "Metadata in ISO 19139",
+        uri: "http://www.isotc211.org/schemas/2005/gmd/"
+      },
+      metadata_fgdc: {
+        label: "Metadata in FGDC",
+        uri: "http://www.opengis.net/cat/csw/csdgm"
+      },
+      metadata_mods: {
+        label: "Metadata in MODS",
+        uri: "http://www.loc.gov/mods/v3"
+      },
+      metadata_html: {
+        label: "Metadata in HTML",
+        uri: "http://www.w3.org/1999/xhtml"
+      },
+      arcgis_feature_layer: {
+        label: "ArcGIS FeatureLayer",
+        uri: "urn:x-esri:serviceType:ArcGIS#FeatureLayer"
+      },
+      arcgis_tiled_map_layer: {
+        label: "ArcGIS TiledMapLayer",
+        uri: "urn:x-esri:serviceType:ArcGIS#TiledMapLayer"
+      },
+      arcgis_dynamic_map_layer: {
+        label: "ArcGIS DynamicMapLayer",
+        uri: "urn:x-esri:serviceType:ArcGIS#DynamicMapLayer"
+      },
+      arcgis_image_map_layer: {
+        label: "ArcGIS ImageMapLayer",
+        uri: "urn:x-esri:serviceType:ArcGIS#ImageMapLayer"
+      },
+      harvard_download: {
+        label: "Harvard Download",
+        uri: "http://schema.org/DownloadAction"
+      },
+      open_index_map: {
+        label: "OpenIndexMap",
+        uri: "https://openindexmaps.org"
+      },
+      oembed: {
+        label: "oEmbed",
+        uri: "https://oembed.com"
+      }
+    }.freeze
+
+    include AttrJson::Model
+
+    validates :category, :value, presence: true
+    validates :category, inclusion:
+      {in: REFERENCE_VALUES.stringify_keys.keys,
+       allow_blank: true,
+       message: "%<value>s is not a valid category"}
+
+    attr_json :category, :string
+    attr_json :value, :string
+  end
+end

data/app/models/document.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+# Document
+class Document < Kithe::Work
+  include AttrJson::Record::QueryScopes
+  include ActiveModel::Validations
+
+  attr_accessor :skip_callbacks
+
+  has_paper_trail
+  belongs_to :import, optional: true
+
+  # Statesman
+  has_many :document_transitions, foreign_key: "kithe_model_id", autosave: false, dependent: :destroy, inverse_of: :document
+
+  # DocumentAccesses
+  has_many :document_accesses, primary_key: "friendlier_id", foreign_key: "friendlier_id", autosave: false, dependent: :destroy,
+    inverse_of: :document
+
+  # DocumentDownloads
+  has_many :document_downloads, primary_key: "friendlier_id", foreign_key: "friendlier_id", autosave: false, dependent: :destroy,
+    inverse_of: :document
+
+  include Statesman::Adapters::ActiveRecordQueries[
+    transition_class: DocumentTransition,
+    initial_state: :draft
+  ]
+
+  def state_machine
+    @state_machine ||= DocumentStateMachine.new(self, transition_class: DocumentTransition)
+  end
+
+  delegate :current_state, to: :state_machine
+
+  before_save :transition_publication_state, unless: :skip_callbacks
+  before_save :set_geometry
+
+  # Indexer
+  self.kithe_indexable_mapper = DocumentIndexer.new
+
+  # Validations
+  validates :title, :dct_accessRights_s, :gbl_resourceClass_sm, :geomg_id_s, presence: true
+
+  # Test for collection and restricted
+  validates :dct_format_s, presence: true, if: :a_downloadable_resource?
+
+  # Downloadable Resouce
+  def a_downloadable_resource?
+    references_json.include?("downloadUrl")
+  end
+
+  validates_with Document::DateRangeValidator
+  validates_with Document::BboxValidator
+  validates_with Document::GeomValidator
+
+  # Definte our AttrJSON attributes
+  Element.all.each do |attribute|
+    next if attribute.solr_field == "dct_references_s"
+
+    if attribute.repeatable?
+      attr_json attribute.solr_field.to_sym, attribute.field_type.to_sym, array: true, default: -> { [] }
+    else
+      attr_json attribute.solr_field.to_sym, attribute.field_type.to_sym, default: ""
+    end
+  end
+
+  attr_json :dct_references_s, Document::Reference.to_type, array: true, default: -> { [] }
+
+  # Index Transformations - *_json functions
+  def references_json
+    references = ActiveSupport::HashWithIndifferentAccess.new
+    send(GeoblacklightAdmin::Schema.instance.solr_fields[:reference]).each { |ref| references[Document::Reference::REFERENCE_VALUES[ref.category.to_sym][:uri]] = ref.value }
+    references = apply_downloads(references)
+    references.to_json
+  end
+
+  def apply_downloads(references)
+    dct_downloads = references["http://schema.org/downloadUrl"]
+    # Make sure downloads exist!
+    if document_downloads.present?
+      multiple_downloads = multiple_downloads_array
+      multiple_downloads << {label: download_text(send(GeoblacklightAdmin::Schema.instance.solr_fields[:format])), url: dct_downloads} if dct_downloads.present?
+      references[:"http://schema.org/downloadUrl"] = multiple_downloads
+    end
+    references
+  end
+
+  def multiple_downloads_array
+    document_downloads.collect { |d| {label: d.label, url: d.value} }
+  end
+
+  ### From GBL
+  ##
+  # Looks up properly formatted names for formats
+  #
+  def proper_case_format(format)
+    if I18n.exists?("geoblacklight.formats.#{format.to_s.parameterize(separator: "_")}")
+      I18n.t("geoblacklight.formats.#{format.to_s.parameterize(separator: "_")}")
+    else
+      format
+    end
+  end
+
+  ##
+  # Wraps download text with proper_case_format
+  #
+  def download_text(format)
+    download_format = proper_case_format(format)
+    prefix = "Original "
+    begin
+      format = download_format
+    rescue
+      # Need to rescue if format doesn't exist
+    end
+    value = prefix + format.to_s
+    value.html_safe
+  end
+  ### End / From GBL
+
+  def access_json
+    access = {}
+    access_urls.each { |au| access[au.institution_code] = au.access_url }
+    access.to_json
+  end
+
+  def created_at_dt
+    created_at&.utc&.iso8601
+  end
+
+  def gbl_mdModified_dt
+    updated_at&.utc&.iso8601
+  end
+
+  # Ensures a manually created "title" makes it into the attr_json "title"
+  def dct_title_s
+    title
+  end
+
+  def date_range_json
+    date_ranges = []
+    unless send(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range]).all?(&:blank?)
+      send(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range]).each do |date_range|
+        start_d, end_d = date_range.split("-")
+        start_d = "*" if start_d == "YYYY" || start_d.nil?
+        end_d = "*" if end_d == "YYYY" || end_d.nil?
+        date_ranges << "[#{start_d} TO #{end_d}]" if start_d.present?
+      end
+    end
+    date_ranges
+  end
+
+  def solr_year_json
+    return [] if send(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range]).blank?
+
+    start_d, _end_d = send(GeoblacklightAdmin::Schema.instance.solr_fields[:date_range]).first.split("-")
+    [start_d] if start_d.presence
+  end
+  alias_method :gbl_indexYear_im, :solr_year_json
+
+  # Export Transformations - to_*
+  def to_csv
+    attributes = GeoblacklightAdmin::Schema.instance.exportable_fields
+    attributes.map do |key, value|
+      if value[:delimited]
+        send(value[:destination])&.join("|")
+      elsif value[:destination] == "dct_references_s"
+        dct_references_s_to_csv(key, value[:destination])
+      elsif value[:destination] == "b1g_publication_state_s"
+        send(:current_state)
+      else
+        send(value[:destination])
+      end
+    end
+  end
+
+  def to_traject
+    Kithe::Model.find_by_friendlier_id(friendlier_id).update_index(writer: Traject::DebugWriter.new({}))
+  end
+
+  def dct_references_s_to_csv(key, destination)
+    send(destination).detect { |ref| ref.category == GeoblacklightAdmin::Schema.instance.dct_references_mappings[key] }.value
+  rescue NoMethodError
+    nil
+  end
+
+  def current_version
+    versions.last.index
+  end
+
+  # Institutional Access URLs
+  def access_urls
+    DocumentAccess.where(friendlier_id: friendlier_id).order(institution_code: :asc)
+  end
+
+  def derive_locn_geometry
+    if send(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry]).present?
+      send(GeoblacklightAdmin::Schema.instance.solr_fields[:geometry])
+    elsif send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]).present?
+      derive_polygon
+    else
+      ""
+    end
+  end
+
+  # Convert BBOX to GEOM Polygon
+  def derive_polygon
+    if send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]).present?
+      # Guard against a whole world polygons
+      if send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]) == "-180,-90,180,90"
+        "ENVELOPE(-180,180,90,-90)"
+      else
+        # "W,S,E,N" convert to "POLYGON((W N, E N, E S, W S, W N))"
+        w, s, e, n = send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]).split(",")
+        "POLYGON((#{w} #{n}, #{e} #{n}, #{e} #{s}, #{w} #{s}, #{w} #{n}))"
+      end
+    else
+      ""
+    end
+  end
+
+  def set_geometry
+    if locn_geometry.blank? && self&.dcat_bbox&.present?
+      self.locn_geometry = derive_polygon
+    end
+  end
+
+  # Convert GEOM for Solr Indexing
+  def derive_dcat_bbox
+    if send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]).present?
+      # "W,S,E,N" convert to "ENVELOPE(W,E,N,S)"
+      w, s, e, n = send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]).split(",")
+      "ENVELOPE(#{w},#{e},#{n},#{s})"
+    else
+      ""
+    end
+  end
+
+  def derive_dcat_centroid
+    if send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]).present?
+      w, s, e, n = send(GeoblacklightAdmin::Schema.instance.solr_fields[:bounding_box]).split(",")
+      "#{(n.to_f + s.to_f) / 2},#{(e.to_f + w.to_f) / 2}"
+    else
+      ""
+    end
+  end
+
+  # Convert three char language code to proper string
+  def iso_language_mapping
+    mapping = []
+
+    if send(GeoblacklightAdmin::Schema.instance.solr_fields[:language]).present?
+      send(GeoblacklightAdmin::Schema.instance.solr_fields[:language]).each do |lang|
+        mapping << GeoblacklightAdmin::IsoLanguageCodes.call[lang]
+      end
+    end
+    mapping
+  end
+
+  private
+
+  def transition_publication_state
+    state_machine.transition_to!(publication_state.downcase) if publication_state_changed?
+  end
+end

data/app/models/document_access.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# DocumentAccess
+class DocumentAccess < ApplicationRecord
+  belongs_to :document, foreign_key: :friendlier_id, primary_key: :friendlier_id
+  after_save :reindex_document
+
+  # Validations
+  validates :institution_code, :access_url, presence: true
+
+  def self.import(file)
+    logger.debug("CSV Import")
+    CSV.foreach(file.path, headers: true) do |row|
+      logger.debug("CSV Row: #{row.to_hash}")
+      document_access = DocumentAccess.find_or_initialize_by(friendlier_id: row[0], institution_code: row[1])
+      document_access.update(row.to_hash)
+    end
+  end
+
+  def self.destroy_all(file)
+    logger.debug("CSV Destroy")
+    CSV.foreach(file.path, headers: true) do |row|
+      logger.debug("CSV Row: #{row.to_hash}")
+      DocumentAccess.destroy_by(id: row[0], friendlier_id: row[1])
+    end
+  end
+
+  def to_csv
+    attributes.values
+  end
+
+  def reindex_document
+    document.save
+  end
+end

data/app/models/document_download.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# DocumentDownload
+class DocumentDownload < ApplicationRecord
+  belongs_to :document, inverse_of: :document_downloads, foreign_key: :friendlier_id, primary_key: :friendlier_id
+  after_save :reindex_document
+
+  # Validations
+  validates :label, :value, presence: true
+
+  def self.import(file)
+    logger.debug("CSV Import")
+    CSV.foreach(file.path, headers: true) do |row|
+      logger.debug("CSV Row: #{row.to_hash}")
+      document_download = DocumentDownload.find_or_initialize_by(friendlier_id: row[0], label: row[1], value: row[2])
+      document_download.update(row.to_hash)
+    end
+  end
+
+  def self.destroy_all(file)
+    logger.debug("CSV Destroy")
+    CSV.foreach(file.path, headers: true) do |row|
+      logger.debug("CSV Row: #{row.to_hash}")
+      DocumentDownload.destroy_by(id: row[0], friendlier_id: row[1])
+    end
+  end
+
+  def to_csv
+    attributes.values
+  end
+
+  def reindex_document
+    document.save
+  end
+end

data/app/models/document_state_machine.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Document Statesman
+class DocumentStateMachine
+  include Statesman::Machine
+
+  state :draft, initial: true
+  state :published
+  state :unpublished
+
+  transition from: :draft, to: %i[draft published unpublished]
+  transition from: :published, to: %i[draft published unpublished]
+  transition from: :unpublished, to: %i[draft published unpublished]
+end

data/app/models/document_transition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Add Document Statesman Transitions
+class DocumentTransition < 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 :document, inverse_of: :document_transitions, foreign_key: "kithe_model_id"
+
+  after_destroy :update_most_recent, if: :most_recent?
+
+  private
+
+  def update_most_recent
+    last_transition = document.document_transitions.order(:sort_key).last
+    return if last_transition.blank?
+
+    last_transition.update_column(:most_recent, true)
+  end
+end