geo_works 0.1.0

data/app/services/geo_works/discovery/geoblacklight_document.rb

@@ -0,0 +1,152 @@
+require 'json-schema'
+require 'open-uri'
+
+module GeoWorks
+  module Discovery
+    # For details on the schema,
+    # @see 'https://github.com/geoblacklight/geoblacklight/wiki/Schema'
+    class GeoblacklightDocument < AbstractDocument
+      # Implements the to_hash method on the abstract document.
+      # @param _args [Array<Object>] arguments needed for the renderer, unused here
+      # @return [Hash] geoblacklight document as a hash
+      def to_hash(_args = nil)
+        return {} unless rights
+        document
+      end
+
+      # Implements the to_json method on the abstract document.
+      # @param _args [Array<Object>] arguments needed for the json renderer, unused here
+      # @return [String] geoblacklight document as a json string
+      def to_json(_args = nil)
+        return '{}' unless rights
+        document.to_json
+      end
+
+      private
+
+        # Builds the geoblacklight document hash.
+        # @return [Hash] geoblacklight document as a hash
+        def document_hash
+          document_hash_required.merge(document_hash_optional)
+        end
+
+        def document_hash_required
+          {
+            geoblacklight_version: '1.0',
+            dc_identifier_s: identifier,
+            layer_slug_s: slug,
+            uuid: slug,
+            dc_title_s: title.first,
+            solr_geom: solr_coverage,
+            dct_provenance_s: provenance,
+            dc_rights_s: rights
+          }
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def document_hash_optional
+          {
+            dc_description_s: description,
+            dc_creator_sm: creator,
+            dc_language_s: language.try(:first),
+            dc_publisher_s: publisher.try(:first),
+            dc_subject_sm: subject,
+            dct_spatial_sm: spatial,
+            dct_temporal_sm: temporal,
+            solr_year_i: layer_year,
+            layer_modified_dt: layer_modified,
+            layer_id_s: layer_id,
+            dct_references_s: clean_document(references).to_json.to_s,
+            layer_geom_type_s: geom_type,
+            dc_format_s: process_format_codes(format),
+            dct_issued_dt: issued
+          }
+        end
+        # rubocop:enable Metrics/LineLength, Metrics/AbcSize
+
+        # Builds the dct_references hash.
+        # @return [Hash] geoblacklight references as a hash
+        def references
+          {
+            'http://schema.org/url' => url,
+            'http://www.opengis.net/cat/csw/csdgm' => fgdc,
+            'http://www.isotc211.org/schemas/2005/gmd/' => iso19139,
+            'http://www.loc.gov/mods/v3' => mods,
+            'http://schema.org/downloadUrl' => download,
+            'http://schema.org/thumbnailUrl' => thumbnail,
+            'http://www.opengis.net/def/serviceType/ogc/wms' => wms_path,
+            'http://www.opengis.net/def/serviceType/ogc/wfs' => wfs_path
+          }
+        end
+
+        # Returns the geoblacklight rights field based on work visibility.
+        # @return [String] geoblacklight access rights
+        def rights
+          case access_rights
+          when Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+            'Public'
+          when Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
+            'Restricted'
+          end
+        end
+
+        # Transforms shapfile, tiff, and arc grid format codes into geoblacklight format codes.
+        # @return [String] geoblacklight format codes
+        def process_format_codes(format)
+          case format
+          when 'ESRI Shapefile'
+            'Shapefile'
+          when 'GTiff'
+            'GeoTIFF'
+          when 'AIG'
+            'ArcGRID'
+          else
+            format
+          end
+        end
+
+        # Returns the content of geoblacklight JSON-Schema document.
+        # @return [Hash] geoblacklight json schema
+        def schema
+          JSON.parse(File.read(schema_path))
+        end
+
+        # Returns a path to the geoblackligh schema document
+        # @return [String]
+        def schema_path
+          File.join(GeoWorks.root, 'config', 'discovery', 'geoblacklight-schema.json')
+        end
+
+        # Validates the geoblacklight document against the json schema.
+        # @return [Boolean] is the document valid?
+        def valid?(doc)
+          JSON::Validator.validate(schema, doc, fragment: '#/definitions/layer')
+        end
+
+        # Returns a hash of errors from json schema validation.
+        # @return [Hash] json schema validation errors
+        def schema_errors(doc)
+          { error: JSON::Validator.fully_validate(schema, doc, fragment: '#/definitions/layer') }
+        end
+
+        # Cleans the geoblacklight document hash by removing unused fields,
+        # then validates it again a json schema. If there are errors, an
+        # error hash is returned, otherwise, the cleaned doc is returned.
+        # @return [Hash] geoblacklight document hash or error hash
+        def document
+          clean = clean_document(document_hash)
+          if valid?(clean)
+            clean
+          else
+            schema_errors(clean)
+          end
+        end
+
+        # Use identifier as layer_id id when there is no wxs_identifier.
+        # Causes errors in Geoblacklight views.
+        def layer_id
+          wxs_identifier || identifier
+        end
+    end
+  end
+end

data/app/services/geo_works/events_generator.rb

@@ -0,0 +1,24 @@
+module GeoWorks
+  class EventsGenerator
+    class_attribute :services
+
+    # Array of event generator services.
+    # - GeoblacklightEventGenerator: synchronizes with geoblacklight instance.
+    # - GeoserverEventGenerator: synchronizes with geoserver instance.
+    self.services = [
+      GeoblacklightEventGenerator,
+      GeoserverEventGenerator
+    ]
+
+    delegate :record_created, to: :generators
+    delegate :record_deleted, to: :generators
+    delegate :record_updated, to: :generators
+    delegate :derivatives_created, to: :generators
+
+    def generators
+      @generators ||= CompositeGenerator.new(
+        services.map(&:new)
+      )
+    end
+  end
+end

data/app/services/geo_works/events_generator/composite_generator.rb

@@ -0,0 +1,18 @@
+module GeoWorks
+  class EventsGenerator
+    class CompositeGenerator
+      attr_reader :generators
+
+      def initialize(generators)
+        @generators = generators
+      end
+
+      def method_missing(m, *args)
+        generators.each do |generator|
+          next unless generator.respond_to? m
+          generator.send(m, args.first)
+        end
+      end
+    end
+  end
+end

data/app/services/geo_works/events_generator/geoblacklight_event_generator.rb

@@ -0,0 +1,53 @@
+module GeoWorks
+  class EventsGenerator
+    class GeoblacklightEventGenerator
+      def record_created(record)
+        publish_message(
+          message("CREATED", record)
+        )
+      end
+
+      def record_deleted(record)
+        publish_message(
+          delete_message("DELETED", record)
+        )
+      end
+
+      def record_updated(record)
+        publish_message(
+          message("UPDATED", record)
+        )
+      end
+
+      private
+
+        def publish_message(message)
+          GeoblacklightJob.perform_later(message)
+        end
+
+        def message(type, record)
+          base_message(type, record).merge("doc" => generate_document(record).to_hash)
+        end
+
+        def delete_message(type, record)
+          base_message(type, record).merge("id" => slug(record))
+        end
+
+        def base_message(type, record)
+          {
+            "id" => record.id,
+            "event" => type
+          }
+        end
+
+        def generate_document(record)
+          Discovery::DocumentBuilder.new(record, Discovery::GeoblacklightDocument.new)
+        end
+
+        def slug(record)
+          return record.id unless record.respond_to?(:provenance)
+          "#{record.provenance.parameterize}-#{record.id}"
+        end
+    end
+  end
+end

data/app/services/geo_works/events_generator/geoserver_event_generator.rb

@@ -0,0 +1,33 @@
+module GeoWorks
+  class EventsGenerator
+    class GeoserverEventGenerator
+      def derivatives_created(record)
+        return unless geo_file_set?(record)
+        publish_message(
+          message("CREATED", record)
+        )
+      end
+
+      private
+
+        def publish_message(message)
+          GeoserverDeliveryJob.perform_later(message)
+        end
+
+        def message(type, record)
+          base_message(type, record)
+        end
+
+        def base_message(type, record)
+          {
+            "id" => record.id,
+            "event" => type
+          }
+        end
+
+        def geo_file_set?(record)
+          record.respond_to?(:geo_file_format?) && record.geo_file_format?
+        end
+    end
+  end
+end

data/app/services/geo_works/file_set_derivatives_service.rb

@@ -0,0 +1,67 @@
+module GeoWorks
+  class FileSetDerivativesService < Hyrax::FileSetDerivativesService
+    attr_reader :file_set
+    delegate :id, :geo_mime_type, to: :file_set
+
+    def initialize(file_set)
+      @file_set = file_set
+    end
+
+    def valid?
+      supported_geo_mime_types.include?(geo_mime_type)
+    end
+
+    def create_derivatives(filename)
+      case geo_mime_type
+      when *GeoWorks::RasterFormatService.select_options.map(&:last)
+        create_raster_derivatives(filename)
+      when *GeoWorks::VectorFormatService.select_options.map(&:last)
+        create_vector_derivatives(filename)
+      end
+
+      # Once all the derivatives are created, send a created message
+      geo_works_events_generator.derivatives_created(file_set)
+    end
+
+    private
+
+      def create_raster_derivatives(filename)
+        GeoWorks::Runners::RasterDerivatives
+          .create(filename, outputs: [{ input_format: geo_mime_type,
+                                        label: :display_raster,
+                                        id: id,
+                                        format: 'tif',
+                                        url: derivative_url('display_raster') },
+                                      { input_format: geo_mime_type,
+                                        label: :thumbnail,
+                                        id: id,
+                                        format: 'png',
+                                        size: '200x150',
+                                        url: derivative_url('thumbnail') }])
+      end
+
+      def create_vector_derivatives(filename)
+        GeoWorks::Runners::VectorDerivatives
+          .create(filename, outputs: [{ input_format: geo_mime_type,
+                                        label: :display_vector,
+                                        id: id,
+                                        format: 'zip',
+                                        url: derivative_url('display_vector') },
+                                      { input_format: geo_mime_type,
+                                        label: :thumbnail,
+                                        id: id,
+                                        format: 'png',
+                                        size: '200x150',
+                                        url: derivative_url('thumbnail') }])
+      end
+
+      def supported_geo_mime_types
+        GeoWorks::RasterFormatService.select_options.map(&:last) +
+          GeoWorks::VectorFormatService.select_options.map(&:last)
+      end
+
+      def geo_works_events_generator
+        @geo_works_events_generator ||= GeoWorks::EventsGenerator.new
+      end
+  end
+end

data/app/services/geo_works/image_format_service.rb

@@ -0,0 +1,6 @@
+module GeoWorks
+  class ImageFormatService
+    include GeoWorks::AuthorityService
+    self.authority = Qa::Authorities::Local.subauthority_for('image_formats')
+  end
+end

data/app/services/geo_works/metadata_format_service.rb

@@ -0,0 +1,6 @@
+module GeoWorks
+  class MetadataFormatService
+    include GeoWorks::AuthorityService
+    self.authority = Qa::Authorities::Local.subauthority_for('metadata_formats')
+  end
+end

data/app/services/geo_works/raster_format_service.rb

@@ -0,0 +1,6 @@
+module GeoWorks
+  class RasterFormatService
+    include GeoWorks::AuthorityService
+    self.authority = Qa::Authorities::Local.subauthority_for('raster_formats')
+  end
+end

data/app/services/geo_works/vector_format_service.rb

@@ -0,0 +1,6 @@
+module GeoWorks
+  class VectorFormatService
+    include GeoWorks::AuthorityService
+    self.authority = Qa::Authorities::Local.subauthority_for('vector_formats')
+  end
+end

data/app/services/hyrax/curation_concern.rb

@@ -0,0 +1,18 @@
+module Hyrax
+  class CurationConcern
+    # This attribute is set by Hyrax::Engine
+    class_attribute :actor_factory
+
+    self.actor_factory = Hyrax::ActorFactory
+
+    # A consumer of this method can inject a different factory
+    # into this class in order to change the behavior of this method.
+    # @param [ActiveFedora::Base] curation_concern a work to be updated
+    # @param [Ability] current_ability the permission object for depositing this
+    #   work.
+    # @return [#create, #update] an actor that can create and update the work
+    def self.actor(curation_concern, current_ability)
+      actor_factory.build(curation_concern, current_ability)
+    end
+  end
+end

data/app/values/geo_works/coverage.rb

@@ -0,0 +1,36 @@
+module GeoWorks
+  class Coverage
+    class ParseError < StandardError; end
+    class InvalidGeometryError < StandardError; end
+
+    attr_reader :n, :e, :s, :w
+
+    def self.parse(str)
+      n = parse_coordinate(str, /northlimit=([\.\d\-]+);/)
+      e = parse_coordinate(str, /eastlimit=([\.\d\-]+);/)
+      s = parse_coordinate(str, /southlimit=([\.\d\-]+);/)
+      w = parse_coordinate(str, /westlimit=([\.\d\-]+);/)
+      raise ParseError, str if n.nil? || e.nil? || s.nil? || w.nil?
+      new(n, e, s, w)
+    rescue
+      nil
+    end
+
+    def self.parse_coordinate(str, regex)
+      Regexp.last_match(1).to_f if str =~ regex
+    end
+
+    def initialize(n, e, s, w)
+      raise InvalidGeometryError, "n=#{n} < s=#{s}" if n.to_f < s.to_f
+      raise InvalidGeometryError, "e=#{e} < w=#{w}" if e.to_f < w.to_f
+      @n = n
+      @e = e
+      @s = s
+      @w = w
+    end
+
+    def to_s
+      "northlimit=#{n}; eastlimit=#{e}; southlimit=#{s}; westlimit=#{w}; units=degrees; projection=EPSG:4326"
+    end
+  end
+end

data/app/values/geo_works/time_period.rb

@@ -0,0 +1,30 @@
+module GeoWorks
+  class TimePeriod
+    attr_accessor :doc, :initial_value
+    def initialize(initial_value, doc)
+      @initial_value = initial_value || []
+      @doc = doc
+    end
+
+    def value
+      append_caldate
+      append_begdate
+      initial_value.uniq!
+      initial_value
+    end
+
+    private
+
+      def append_caldate
+        doc.at_xpath('//idinfo/timeperd/timeinfo/mdattim/sngdate/caldate | //idinfo/timeperd/timeinfo/sngdate/caldate').tap do |node|
+          initial_value << node.text[0..3] unless node.nil? # extract year only
+        end
+      end
+
+      def append_begdate
+        doc.at_xpath('//idinfo/timeperd/timeinfo/rngdates/begdate').tap do |node|
+          initial_value << node.text[0..3] unless node.nil? # extract year only
+        end
+      end
+  end
+end