geo_concerns 0.0.7 → 0.0.8

data/app/jobs/delivery_job.rb

@@ -0,0 +1,18 @@
+require 'uri'
+
+##
+# Delivers derivatives to external services, like GeoServer
+##
+class DeliveryJob < ActiveJob::Base
+  queue_as CurationConcerns.config.ingest_queue_name
+
+  ##
+  # Precondition is that all derivatives are created and saved.
+  # @param [FileSet] file_set
+  # @param [String] content_url contains the display copy to deliver
+  def perform(file_set, content_url)
+    uri = URI.parse(content_url)
+    raise NotImplementedError, 'Only supports file URLs' unless uri.scheme == 'file'
+    GeoConcerns::DeliveryService.new.publish(file_set.id, uri.path)
+  end
+end

data/app/models/concerns/geo_concerns/file_set/derivatives.rb

@@ -3,18 +3,27 @@ module GeoConcerns
     module Derivatives
       extend ActiveSupport::Concern
 
+      # rubocop:disable Metrics/MethodLength
       def create_derivatives(filename)
+        content_url = nil
         case geo_mime_type
         when *GeoConcerns::ImageFormatService.select_options.map(&:last)
           image_derivatives(filename)
         when *GeoConcerns::RasterFormatService.select_options.map(&:last)
           raster_derivatives(filename)
+          content_url = derivative_url('display_raster')
         when *GeoConcerns::VectorFormatService.select_options.map(&:last)
           vector_derivatives(filename)
+          content_url = derivative_url('display_vector')
         end
 
         super
+
+        # Once all the derivatives are created, we can run a job to
+        # deliver them to external services
+        DeliveryJob.perform_later(self, content_url) if content_url.present?
       end
+      # rubocop:enable Metrics/MethodLength
 
       def image_derivatives(filename)
         Hydra::Derivatives::ImageDerivatives

data/app/models/concerns/geo_concerns/metadata_extraction_helper.rb

@@ -2,16 +2,15 @@ module GeoConcerns
   module MetadataExtractionHelper
     # Extracts properties from the constitutent external metadata file
     # @return [Hash]
-    def extract_metadata
+    def extract_metadata(id)
       return {} if metadata_files.blank?
-      # TODO: Does not support multiple external metadata files
-      raise NotImplementedError if metadata_files.length > 1
-      metadata_files.first.extract_metadata
+      metadata_file = metadata_files.find { |f| f.id == id }
+      metadata_file.extract_metadata if metadata_file
     end
 
     # Sets properties from the constitutent external metadata file
-    def populate_metadata
-      extract_metadata.each do |k, v|
+    def populate_metadata(id)
+      extract_metadata(id).each do |k, v|
         send("#{k}=".to_sym, v) # set each property
       end
     end
@@ -19,9 +18,9 @@ module GeoConcerns
     attr_accessor :should_populate_metadata
 
     def should_populate_metadata=(args)
-      @should_populate_metadata = args.present?
+      @should_populate_metadata = args.present? && args != ''
       return unless should_populate_metadata
-      populate_metadata
+      populate_metadata(args)
       save
     end
   end

data/app/models/concerns/geo_concerns/solr_document_behavior.rb

@@ -1,25 +1,41 @@
 module GeoConcerns
   module SolrDocumentBehavior
     extend ActiveSupport::Concern
+    include CurationConcerns::SolrDocumentBehavior
 
+    # @return [Array<String>]
     def spatial
       fetch(Solrizer.solr_name('spatial'), [])
     end
 
+    # @return [Array<String>]
     def temporal
       fetch(Solrizer.solr_name('temporal'), [])
     end
 
+    # @return [String]
     def issued
       fetch(Solrizer.solr_name('issued'), nil)
     end
 
+    # @return [String]
     def coverage
       fetch(Solrizer.solr_name('coverage'), nil)
     end
 
+    # @return [String]
     def provenance
-      fetch(Solrizer.solr_name('provenance'), nil)
+      name = I18n.t('curation_concerns.institution.name')
+      raise ArgumentError, "Provenance required in configuration" unless name.present?
+      name
+    end
+
+    # @return [DateTime]
+    def layer_modified
+      # TODO: `date_modified` isn't working correctly -- it's stored as a string not a date
+      # @see 'https://github.com/projecthydra/curation_concerns/issues/957'
+      dt = first(Solrizer.solr_name('system_modified', :stored_sortable, type: :date))
+      dt.nil? ? nil : DateTime.parse(dt).utc
     end
   end
 end

data/app/presenters/geo_concerns/geo_concerns_show_presenter.rb

@@ -1,6 +1,7 @@
 module GeoConcerns
   class GeoConcernsShowPresenter < CurationConcerns::WorkShowPresenter
-    delegate :spatial, :temporal, :issued, :coverage, :provenance, to: :solr_document
+    delegate :spatial, :temporal, :issued, :coverage, :provenance, :layer_modified,
+             to: :solr_document
     class_attribute :file_format_service
 
     def geo_file_set_presenters
@@ -17,6 +18,13 @@ module GeoConcerns
       end
     end
 
+    def parent_work_presenters
+      # filter out collection presenters
+      collection_presenters.select do |member|
+        member.model_name.name != "Collection"
+      end
+    end
+
     def attribute_to_html(field, options = {})
       if field == :coverage
         GeoConcerns::CoverageRenderer.new(field, send(field), options).render

data/app/processors/geo_concerns/processors/base_geo_processor.rb

@@ -37,23 +37,23 @@ module GeoConcerns
           "#{File.dirname(path)}/#{File.basename(path, File.extname(path))}_#{time}"
         end
 
-        # Uses imagemagick to resize an image and convert it to jpeg format.
+        # Uses imagemagick to resize an image and convert it to the output format.
         # Keeps the aspect ratio of the original image and adds padding to
-        # to the ouput image.
+        # to the output image. The file extension is the output format.
         # @param in_path [String] file input path
-        # @param out_path [String] processor output file path
+        # @param out_path [String] processor output file path.
         # @param options [Hash] creation options
+        # @option options [String] `:output_size` as "w h" or "wxh"
         def self.convert(in_path, out_path, options)
-          size = options[:output_size].tr(' ', 'x')
-          # byebug
-          image = MiniMagick::Image.open(in_path)
-          image.format 'jpg'
+          image = MiniMagick::Image.open(in_path) # copies image
           image.combine_options do |i|
+            size = options[:output_size].tr(' ', 'x')
             i.resize size
             i.background 'white'
             i.gravity 'center'
             i.extent size
           end
+          image.format File.extname(out_path).gsub(/^\./, '')
           image.write(out_path)
         end
       end

data/app/services/geo_concerns/delivery/geoserver.rb

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'rgeoserver'
+require 'yaml'
+
+module GeoConcerns
+  module Delivery
+    class Geoserver
+      DEFAULT_CONFIG = {
+        url: 'http://localhost:8181/geoserver/rest',
+        user: 'admin',
+        password: 'geoserver'
+      }.with_indifferent_access.freeze
+
+      attr_reader :config
+
+      def initialize
+        begin
+          data = File.read(Rails.root.join('config', 'geoserver.yml'))
+          @config = YAML.load(data)['geoserver'].with_indifferent_access.freeze
+        rescue Errno::ENOENT
+          @config = DEFAULT_CONFIG
+        end
+        validate!
+      end
+
+      def catalog
+        @catalog ||= RGeoServer.catalog(config)
+      end
+
+      def publish(id, filename, type = :vector)
+        case type
+        when :vector
+          publish_vector(id, filename)
+        when :raster
+          publish_raster(id, filename)
+        else
+          raise ArgumentError, "Unknown file type #{type}"
+        end
+      end
+
+      private
+
+        def validate!
+          %w(url user password).map(&:to_sym).each do |k|
+            raise ArgumentError, "Missing #{k} in configuration" unless config[k].present?
+          end
+        end
+
+        def publish_vector(id, filename)
+          raise ArgumentError, "Not ZIPed Shapefile: #{filename}" unless filename =~ /\.zip$/
+
+          workspace = RGeoServer::Workspace.new catalog, name: 'geo'
+          workspace.save if workspace.new?
+          datastore = RGeoServer::DataStore.new catalog, workspace: workspace, name: id
+          datastore.upload_file filename, publish: true
+        end
+
+        def publish_raster(_id, filename)
+          raise ArgumentError, "Not GeoTIFF: #{filename}" unless filename =~ /\.tif$/
+          raise NotImplementedError
+        end
+    end
+  end
+end

data/app/services/geo_concerns/delivery_service.rb

@@ -0,0 +1,11 @@
+module GeoConcerns
+  class DeliveryService
+    attr_reader :geoserver
+
+    def initialize
+      @geoserver = GeoConcerns::Delivery::Geoserver.new
+    end
+
+    delegate :publish, to: :geoserver
+  end
+end

data/app/services/geo_concerns/derivative_path.rb

@@ -1,6 +1,6 @@
 module GeoConcerns
   class DerivativePath < CurationConcerns::DerivativePath
-    def self.extension(destination_name)
+    def extension
       case destination_name
       when 'thumbnail'
         ".#{MIME::Types.type_for('jpg').first.extensions.first}"

data/app/services/geo_concerns/discovery/abstract_document.rb

@@ -1,10 +1,10 @@
 module GeoConcerns
   module Discovery
     class AbstractDocument
-      attr_accessor :id, :provenance, :creator, :subject, :spatial, :temporal,
-                    :title, :identifier, :description, :access_rights, :language,
-                    :publisher, :slug, :solr_coverage, :geo_rss_coverage, :layer_year,
-                    :date_modified, :geom_type, :format, :resource_type, :wxs_identifier,
+      attr_accessor :identifier, :provenance, :creator, :subject, :spatial, :temporal,
+                    :title, :description, :access_rights, :language, :issued,
+                    :publisher, :slug, :solr_coverage, :layer_year,
+                    :layer_modified, :geom_type, :format, :resource_type, :wxs_identifier,
                     :dct_references, :fgdc, :iso19139, :mods, :download, :url, :thumbnail
 
       # Cleans the document hash by removing unused fields.

data/app/services/geo_concerns/discovery/document_builder/basic_metadata_builder.rb

@@ -20,7 +20,7 @@ module GeoConcerns
           # Returns an array of attributes to add to document.
           # @return [Array] attributes
           def simple_attributes
-            [:id, :creator, :subject, :spatial, :temporal,
+            [:creator, :subject, :spatial, :temporal,
              :title, :provenance, :language, :publisher]
           end
 
@@ -35,7 +35,8 @@ module GeoConcerns
           # Builds more complex metadata attributes.
           # @param [AbstractDocument] discovery document
           def build_complex_attributes(document)
-            document.identifier = identifier
+            document.identifier = URI.join(I18n.t('geo_concerns.institution.uri'),
+                                           geo_concern.id).to_s
             document.description = description
             document.access_rights = geo_concern.solr_document.visibility
             document.slug = slug
@@ -52,16 +53,8 @@ module GeoConcerns
           # Returns the document slug for use in discovery systems.
           # @return [String] document slug
           def slug
-            return unless geo_concern.provenance
-            "#{geo_concern.provenance[0].downcase.tr(' ', '-')}-#{geo_concern.id}"
-          end
-
-          # Returns the document identifier. If there is no identifier,
-          # the work id is used instead.
-          # @return [String] document identifier
-          def identifier
-            field = geo_concern.solr_document[:identifier_tesim]
-            field ? field.first : geo_concern.id
+            return geo_concern.id unless geo_concern.provenance
+            "#{geo_concern.provenance.parameterize}-#{geo_concern.id}"
           end
       end
     end

data/app/services/geo_concerns/discovery/document_builder/date_builder.rb

@@ -12,25 +12,36 @@ module GeoConcerns
         # @param [AbstractDocument] discovery document
         def build(document)
           document.layer_year = layer_year
-          document.date_modified = date_modified
+          document.layer_modified = layer_modified
+          document.issued = issued
         end
 
         private
 
           # Returns a year associated with the layer. Taken from first
-          # value in temporal or from date uploaded. If neither is valid,
-          # the current year is used.
+          # value in temporal.
           # @return [Integer] year
           def layer_year
-            date = geo_concern.temporal.first || geo_concern.date_uploaded
+            date = geo_concern.temporal.first
             year = date.match(/(?<=\D|^)(\d{4})(?=\D|$)/)
-            year ? year[0].to_i : Time.current.year
+            year ? year[0].to_i : nil
           end
 
           # Returns the date the work was modified.
-          # @return [String] date in rfc3339 format.
-          def date_modified
-            DateTime.rfc3339(geo_concern.solr_document[:date_modified_dtsi]).to_s
+          # @return [String] date in XMLSchema format.
+          def layer_modified
+            geo_concern.layer_modified.try(:xmlschema)
+          end
+
+          # Returns the date the layer was issued.
+          # @return [String] date in XMLSchema format.
+          def issued
+            datetime = geo_concern.issued.first
+            datetime = DateTime.parse(datetime.to_s).utc
+            # TODO: Rails 4 doesn't implement the timezone correctly -- it adds "+00:00" not "Z"
+            Rails::VERSION::MAJOR == 4 ? datetime.utc.strftime('%FT%TZ') : datetime.utc.xmlschema
+          rescue
+            ''
           end
       end
     end

data/app/services/geo_concerns/discovery/document_builder/spatial_builder.rb

@@ -11,7 +11,6 @@ module GeoConcerns
         # Builds spatial fields such as bounding box and solr geometry.
         # @param [AbstractDocument] discovery document
         def build(document)
-          document.geo_rss_coverage = to_geo_rss
           document.solr_coverage = to_solr
         end
 
@@ -23,13 +22,9 @@ module GeoConcerns
             @coverage ||= GeoConcerns::Coverage.parse(geo_concern.coverage.first)
           end
 
-          # Returns the coverage as georss.
-          # @return [String] coverage in georss format
-          def to_geo_rss
-            "#{coverage.s} #{coverage.w} #{coverage.n} #{coverage.e}"
-          end
-
-          # Returns the coverage in solr format.
+          # Returns the coverage in solr format. For example:
+          # `ENVELOPE(minX, maxX, maxY, minY)`
+          # @see 'https://cwiki.apache.org/confluence/display/solr/Spatial+Search'
           # @return [String] coverage in solr format
           def to_solr
             "ENVELOPE(#{coverage.w}, #{coverage.e}, #{coverage.n}, #{coverage.s})"

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

@@ -1,8 +1,14 @@
 require 'json-schema'
+require 'open-uri'
 
 module GeoConcerns
   module Discovery
+    # For details on the schema,
+    # @see 'https://github.com/geoblacklight/geoblacklight/wiki/Schema'
     class GeoblacklightDocument < AbstractDocument
+      GEOBLACKLIGHT_RELEASE_VERSION = 'v1.1.2'.freeze
+      GEOBLACKLIGHT_SCHEMA = JSON.parse(open("https://raw.githubusercontent.com/geoblacklight/geoblacklight/#{GEOBLACKLIGHT_RELEASE_VERSION}/schema/geoblacklight-schema.json").read).freeze
+
       # 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
@@ -21,30 +27,39 @@ module GeoConcerns
 
         # Builds the geoblacklight document hash.
         # @return [Hash] geoblacklight document as a hash
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         def document_hash
+          document_hash_required.merge(document_hash_optional)
+        end
+
+        def document_hash_required
           {
-            uuid: id,
+            geoblacklight_version: '1.0',
             dc_identifier_s: identifier,
+            layer_slug_s: 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_rights_s: rights,
-            dct_provenance_s: provenance.first,
             dc_creator_sm: creator,
-            dc_language_s: language.first,
-            dc_publisher_s: publisher.first,
+            dc_language_s: language.try(:first),
+            dc_publisher_s: publisher.try(:first),
             dc_subject_sm: subject,
             dct_spatial_sm: spatial,
             dct_temporal_sm: temporal,
-            layer_slug_s: slug,
-            georss_box_s: geo_rss_coverage,
-            solr_geom: solr_coverage,
             solr_year_i: layer_year,
-            layer_modified_dt: date_modified,
+            layer_modified_dt: layer_modified,
             layer_id_s: wxs_identifier,
-            dct_references_s: clean_document(references).to_json,
+            dct_references_s: clean_document(references).to_json.to_s,
             layer_geom_type_s: geom_type,
-            dc_format_s: process_format_codes(format)
+            dc_format_s: process_format_codes(format),
+            dct_issued_dt: issued
           }
         end
         # rubocop:enable Metrics/LineLength, Metrics/AbcSize
@@ -87,22 +102,22 @@ module GeoConcerns
           end
         end
 
-        # Returns the location of geoblacklight json schema document.
-        # @return [String] geoblacklight json schema document path
+        # Returns the content of geoblacklight JSON-Schema document.
+        # @return [Hash] geoblacklight json schema
         def schema
-          Rails.root.join('config', 'discovery', 'geoblacklight_schema.json').to_s
+          GEOBLACKLIGHT_SCHEMA
         end
 
         # Validates the geoblacklight document against the json schema.
         # @return [Boolean] is the document valid?
         def valid?(doc)
-          JSON::Validator.validate(schema, doc, validate_schema: true)
+          JSON::Validator.validate(schema, doc, fragment: '#/properties/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) }
+          { error: JSON::Validator.fully_validate(schema, doc, fragment: '#/properties/layer') }
         end
 
         # Cleans the geoblacklight document hash by removing unused fields,