blacklight-maps 0.5.2 → 1.1.0

data/config/locales/blacklight-maps.nl.yml

@@ -0,0 +1,21 @@
+nl:
+  blacklight:
+
+    maps:
+      interactions:
+        bbox_search: 'Bekijk items die kruisen met dit selectiekader'
+        placename_search: 'Bekijk items van deze locatie'
+        item: 'item'
+        point_search: 'Bekijk items van deze locatie'
+        search_ctrl_cue: 'Zoek naar alle items in het huidige kaartvenster'
+      title: 'Kaart'
+      leader_html: "Klik op een markering om naar items op die locatie te zoeken of gebruik de 🔍 knop om te zoeken naar alle items in het huidige kaartvenster."
+
+    search:
+      filters:
+        coordinates:
+          bbox: 'Begrenzende doos'
+          point: 'Coördinaten'
+      view:
+        maps: 'Kaart'
+

data/config/locales/blacklight-maps.pt-BR.yml

@@ -0,0 +1,21 @@
+pt-BR:
+  blacklight:
+
+    maps:
+      interactions:
+        bbox_search: 'Exibir itens que se cruzam com esta caixa delimitadora'
+        placename_search: 'Ver itens deste local'
+        item: 'item'
+        point_search: 'Ver itens deste local'
+        search_ctrl_cue: 'Pesquise todos os itens na janela atual do mapa'
+      title: 'Mapa'
+      leader_html: "Clique em um marcador para procurar itens desse local ou use o 🔍 para procurar todos os itens na janela atual do mapa."
+
+    search:
+      filters:
+        coordinates:
+          bbox: 'Caixa delimitadora'
+          point: 'Coordenadas'
+      view:
+        maps: 'Mapa'
+

data/config/locales/blacklight-maps.sq.yml

@@ -0,0 +1,21 @@
+sq:
+  blacklight:
+
+    maps:
+      interactions:
+        bbox_search: 'Shikoni artikujt që kryqëzohen me këtë kuti kufizuese'
+        placename_search: 'Shikoni artikujt nga ky vendndodhje'
+        item: 'artikull'
+        point_search: 'Shikoni artikujt nga ky vendndodhje'
+        search_ctrl_cue: 'Kërkoni për të gjithë artikujt brenda dritares aktuale të hartës'
+      title: 'Hartë'
+      leader_html: "Klikoni në një shënues për të kërkuar artikuj nga ai vend, ose përdorni 🔍 butoni për të kërkuar të gjitha artikujt brenda dritares aktuale të hartës."
+
+    search:
+      filters:
+        coordinates:
+          bbox: 'Kuti kufizuese'
+          point: 'Koordinon'
+      view:
+        maps: 'Hartë'
+

data/config/routes.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 Rails.application.routes.draw do
-  get 'map', :to => 'catalog#map', :as => 'map'
+  get 'map', to: 'catalog#map', as: 'map'
 end
-

data/lib/blacklight/maps.rb

@@ -1,13 +1,19 @@
-require "blacklight/maps/version"
+# frozen_string_literal: true
+
+require 'blacklight/maps/version'
 
 module Blacklight
   module Maps
-    require 'blacklight/maps/controller_override'
+    require 'blacklight/maps/controller'
     require 'blacklight/maps/render_constraints_override'
     require 'blacklight/maps/engine'
     require 'blacklight/maps/export'
     require 'blacklight/maps/geometry'
     require 'blacklight/maps/maps_search_builder'
 
+    # returns the full path to the blacklight plugin installation
+    def self.root
+      @root ||= File.expand_path(File.dirname(File.dirname(File.dirname(__FILE__))))
+    end
   end
 end

data/lib/blacklight/maps/controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BlacklightMaps
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      helper BlacklightMaps::RenderConstraintsOverride
+    end
+
+    def map
+      (@response, @document_list) = search_service.search_results
+      params[:view] = 'maps'
+      respond_to do |format|
+        format.html
+      end
+    end
+
+    ##
+    # BlacklightMaps override: update to look for spatial query params
+    # Check if any search parameters have been set
+    # @return [Boolean]
+    def has_search_parameters?
+      params[:coordinates].present? || super
+    end
+  end
+end

data/lib/blacklight/maps/engine.rb

@@ -1,29 +1,28 @@
+# frozen_string_literal: true
+
 require 'blacklight'
-require 'leaflet-rails'
-require 'leaflet-markercluster-rails'
 
 module Blacklight
   module Maps
     class Engine < Rails::Engine
-
       # Set some default configurations
-      initializer 'blacklight-maps.default_config' do |app|
-        Blacklight::Configuration.default_values[:view].maps.geojson_field = "geojson"
-        Blacklight::Configuration.default_values[:view].maps.placename_property = "placename"
-        Blacklight::Configuration.default_values[:view].maps.coordinates_field = "coordinates"
-        Blacklight::Configuration.default_values[:view].maps.search_mode = "placename" # or 'coordinates'
+      initializer 'blacklight-maps.default_config' do |_app|
+        Blacklight::Configuration.default_values[:view].maps.geojson_field = 'geojson_ssim'
+        Blacklight::Configuration.default_values[:view].maps.placename_property = 'placename'
+        Blacklight::Configuration.default_values[:view].maps.coordinates_field = 'coordinates_srpt'
+        Blacklight::Configuration.default_values[:view].maps.search_mode = 'placename' # or 'coordinates'
         Blacklight::Configuration.default_values[:view].maps.spatial_query_dist = 0.5
-        Blacklight::Configuration.default_values[:view].maps.placename_field = "placename_field"
-        Blacklight::Configuration.default_values[:view].maps.coordinates_facet_field = "coordinates_facet_field"
-        Blacklight::Configuration.default_values[:view].maps.facet_mode = "geojson" # or 'coordinates'
-        Blacklight::Configuration.default_values[:view].maps.tileurl = "http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
+        Blacklight::Configuration.default_values[:view].maps.placename_field = 'subject_geo_ssim'
+        Blacklight::Configuration.default_values[:view].maps.coordinates_facet_field = 'coordinates_ssim'
+        Blacklight::Configuration.default_values[:view].maps.facet_mode = 'geojson' # or 'coordinates'
+        Blacklight::Configuration.default_values[:view].maps.tileurl = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'
         Blacklight::Configuration.default_values[:view].maps.mapattribution = 'Map data &copy; <a href="http://openstreetmap.org">OpenStreetMap</a> contributors, <a href="http://creativecommons.org/licenses/by-sa/2.0/">CC-BY-SA</a>'
         Blacklight::Configuration.default_values[:view].maps.maxzoom = 18
         Blacklight::Configuration.default_values[:view].maps.show_initial_zoom = 5
       end
 
       # Add our helpers
-      initializer 'blacklight-maps.helpers' do |app|
+      initializer 'blacklight-maps.helpers' do |_app|
         ActionView::Base.send :include, BlacklightMapsHelper
       end
 

data/lib/blacklight/maps/export.rb

@@ -1,5 +1,6 @@
-module BlacklightMaps
+# frozen_string_literal: true
 
+module BlacklightMaps
   # This class provides the ability to export a response document to GeoJSON.
   # The export is formated as a GeoJSON FeatureCollection, where the features
   # consist of an array of Point features.  For more on the GeoJSON
@@ -8,146 +9,164 @@ module BlacklightMaps
   class GeojsonExport
     include BlacklightMaps
 
-    # controller is a Blacklight CatalogController object passed by a helper
-    # action is the controller action
-    # response_docs is passed by a helper, and is either:
+    # @param controller [CatalogController]
+    # @param action [Symbol] the controller action
+    # @param response_docs [Array || SolrDocument] either:
     #  - index view, map view: an array of facet values
     #  - show view: the document object
-    # options is an optional hash of possible configuration options
-    def initialize(controller, action, response_docs, options={})
+    # @param options [Hash] optional hash of configuration options
+    def initialize(controller, action, response_docs, options = {})
       @controller = controller
       @action = action
       @response_docs = response_docs
       @options = options
+      @features = []
     end
 
-    # build the GeoJSON FeatureCollection
+    # builds the GeoJSON FeatureCollection
     def to_geojson
-      geojson_docs = { type: 'FeatureCollection',
-                       features: build_geojson_features }
-      geojson_docs.to_json
+      { type: 'FeatureCollection', features: build_geojson_features }.to_json
     end
 
     private
 
-    def blacklight_maps_config
+    def maps_config
       @controller.blacklight_config.view.maps
     end
 
     def geojson_field
-      blacklight_maps_config.geojson_field
+      maps_config.geojson_field
     end
 
     def coordinates_field
-      blacklight_maps_config.coordinates_field
+      maps_config.coordinates_field
     end
 
-    def search_mode
-      blacklight_maps_config.search_mode
+    def build_geojson_features
+      if @action == :index || @action == :map
+        build_index_features
+      elsif @action == :show
+        build_show_features
+      end
+      @features
     end
 
-    def facet_mode
-      blacklight_maps_config.facet_mode
+    # build GeoJSON features array for index and map views
+    def build_index_features
+      @response_docs.each do |geofacet|
+        @features << if maps_config.facet_mode == 'coordinates'
+                       build_feature_from_coords(geofacet.value, geofacet.hits)
+                     else
+                       build_feature_from_geojson(geofacet.value, geofacet.hits)
+                     end
+      end
     end
 
-    def placename_property
-      blacklight_maps_config.placename_property
+    # build GeoJSON features array for show view
+    def build_show_features
+      doc = @response_docs
+      return unless doc[geojson_field] || doc[coordinates_field]
+
+      if doc[geojson_field]
+        build_features_from_geojson(doc[geojson_field])
+      elsif doc[coordinates_field]
+        build_features_from_coords(doc[coordinates_field])
+      end
     end
 
-    # build GeoJSON features array
-    # determine how to build GeoJSON feature based on config and controller#action
-    def build_geojson_features
-      features = []
-      case @action
-        when "index", "map"
-          @response_docs.each do |geofacet|
-            if facet_mode == "coordinates"
-              features.push(build_feature_from_coords(geofacet.value, geofacet.hits))
-            else
-              features.push(build_feature_from_geojson(geofacet.value, geofacet.hits))
-            end
-          end
-        when "show"
-          doc = @response_docs
-          return unless doc[geojson_field] || doc[coordinates_field]
-          if doc[geojson_field]
-            doc[geojson_field].uniq.each do |loc|
-              features.push(build_feature_from_geojson(loc))
-            end
-          elsif doc[coordinates_field]
-            doc[coordinates_field].uniq.each do |coords|
-              features.push(build_feature_from_coords(coords))
-            end
-          end
+    def build_features_from_geojson(geojson_field_values)
+      return unless geojson_field_values
+
+      geojson_field_values.uniq.each do |loc|
+        @features << build_feature_from_geojson(loc)
       end
-      features
     end
 
-    # build blacklight-maps GeoJSON feature from GeoJSON-formatted data
+    def build_features_from_coords(coordinates_field_values)
+      return unless coordinates_field_values
+
+      coordinates_field_values.uniq.each do |coords|
+        @features << build_feature_from_coords(coords)
+      end
+    end
+
+    # build GeoJSON feature from incoming GeoJSON data
     # turn bboxes into points for index view so we don't get weird mix of boxes and markers
+    # @param loc [Hash]
+    # @param hits [Integer]
     def build_feature_from_geojson(loc, hits = nil)
-      geojson_hash = JSON.parse(loc).deep_symbolize_keys
-      if @action != "show" && geojson_hash[:bbox]
-        geojson_hash[:geometry][:coordinates] = Geometry::Point.new(Geometry::BoundingBox.new(geojson_hash[:bbox]).find_center).normalize_for_search
-        geojson_hash[:geometry][:type] = "Point"
-        geojson_hash.delete(:bbox)
+      geojson = JSON.parse(loc).deep_symbolize_keys
+      if @action != :show && geojson[:bbox]
+        bbox = Geometry::BoundingBox.new(geojson[:bbox])
+        geojson[:geometry][:coordinates] = Geometry::Point.new(bbox.find_center).normalize_for_search
+        geojson[:geometry][:type] = 'Point'
+        geojson.delete(:bbox)
       end
-      geojson_hash[:properties] ||= {}
-      geojson_hash[:properties][:hits] = hits.to_i if hits
-      geojson_hash[:properties][:popup] = render_leaflet_popup_content(geojson_hash, hits)
-      geojson_hash
+      geojson[:properties] ||= {}
+      geojson[:properties][:hits] = hits.to_i if hits
+      geojson[:properties][:popup] = render_leaflet_popup_content(geojson, hits)
+      geojson
     end
 
-    # build blacklight-maps GeoJSON feature from coordinate data
+    # build GeoJSON feature from incoming raw coordinate data
     # turn bboxes into points for index view so we don't get weird mix of boxes and markers
+    # @param coords [String]
+    # @param hits [Integer]
     def build_feature_from_coords(coords, hits = nil)
-      geojson_hash = {type: "Feature", geometry: {}, properties: {}}
-      if coords.scan(/[\s]/).length == 3 # bbox
-        if @action != "show"
-          geojson_hash[:geometry][:type] = "Point"
-          geojson_hash[:geometry][:coordinates] = Geometry::Point.new(Geometry::BoundingBox.from_lon_lat_string(coords).find_center).normalize_for_search
-        else
-          coords_array = coords.split(' ').map { |v| v.to_f }
-          geojson_hash[:bbox] = coords_array
-          geojson_hash[:geometry][:type] = "Polygon"
-          geojson_hash[:geometry][:coordinates] = [[[coords_array[0],coords_array[1]],
-                                                    [coords_array[2],coords_array[1]],
-                                                    [coords_array[2],coords_array[3]],
-                                                    [coords_array[0],coords_array[3]],
-                                                    [coords_array[0],coords_array[1]]]]
-        end
-      elsif coords.match(/^[-]?[\d]*[\.]?[\d]*[ ,][-]?[\d]*[\.]?[\d]*$/) # point
-        geojson_hash[:geometry][:type] = "Point"
-        if coords.match(/,/)
-          coords_array = coords.split(',').reverse
-        else
-          coords_array = coords.split(' ')
-        end
-        geojson_hash[:geometry][:coordinates] = coords_array.map { |v| v.to_f }
+      geojson = { type: 'Feature', properties: {} }
+      if coords =~ /ENVELOPE/ # bbox
+        geojson.merge!(build_bbox_feature_from_coords(coords))
+      elsif coords =~ /^[-]?[\d]*[\.]?[\d]*[ ,][-]?[\d]*[\.]?[\d]*$/ # point
+        geojson[:geometry] = build_point_geometry(coords)
       else
         Rails.logger.error("This coordinate format is not yet supported: '#{coords}'")
       end
-      geojson_hash[:properties] = { popup: render_leaflet_popup_content(geojson_hash, hits) } if geojson_hash[:geometry][:coordinates]
-      geojson_hash[:properties][:hits] = hits.to_i if hits
-      geojson_hash
+      geojson[:properties] = { popup: render_leaflet_popup_content(geojson, hits) } if geojson[:geometry][:coordinates]
+      geojson[:properties][:hits] = hits.to_i if hits
+      geojson
+    end
+
+    # @param coords [String]
+    def build_bbox_feature_from_coords(coords)
+      geojson = { geometry: {} }
+      bbox = Geometry::BoundingBox.from_wkt_envelope(coords)
+      if @action != :show
+        geojson[:geometry][:type] = 'Point'
+        geojson[:geometry][:coordinates] = Geometry::Point.new(bbox.find_center).normalize_for_search
+      else
+        coords_array = bbox.to_a
+        geojson[:bbox] = coords_array
+        geojson[:geometry][:type] = 'Polygon'
+        geojson[:geometry][:coordinates] = bbox.geojson_geometry_array
+      end
+      geojson
+    end
+
+    # @param coords [String]
+    def build_point_geometry(coords)
+      geometry = { type: 'Point' }
+      coords_array = coords =~ /,/ ? coords.split(',').reverse : coords.split(' ')
+      geometry[:coordinates] = coords_array.map(&:to_f)
+      geometry
     end
 
-    # Render to string the partial for each individual doc.
+    # Render to string the partial for each individual feature.
     # For placename searching, render catalog/map_placename_search partial,
-    #  full geojson hash is passed to the partial for easier local customization
+    #  pass the full geojson hash to the partial for easier local customization
     # For coordinate searches (or features with only coordinate data),
     #  render catalog/map_coordinate_search partial
-    def render_leaflet_popup_content(geojson_hash, hits=nil)
-      if search_mode == 'placename' && geojson_hash[:properties][placename_property.to_sym]
-        @controller.render_to_string partial: 'catalog/map_placename_search',
-                                     locals: { geojson_hash: geojson_hash, hits: hits }
+    # @param geojson [Hash]
+    # @param hits [Integer]
+    def render_leaflet_popup_content(geojson, hits = nil)
+      if maps_config.search_mode == 'placename' &&
+         geojson[:properties][maps_config.placename_property.to_sym]
+        partial = 'catalog/map_placename_search'
+        locals = { geojson_hash: geojson, hits: hits }
       else
-        @controller.render_to_string partial: 'catalog/map_spatial_search',
-                                     locals: { coordinates: geojson_hash[:bbox].presence || geojson_hash[:geometry][:coordinates],
-                                               hits: hits }
+        partial = 'catalog/map_spatial_search'
+        locals = { coordinates: geojson[:bbox].presence || geojson[:geometry][:coordinates], hits: hits }
       end
+      @controller.render_to_string(partial: partial, locals: locals)
     end
-
   end
-
 end

data/lib/blacklight/maps/geometry.rb

@@ -1,15 +1,14 @@
-module BlacklightMaps
+# frozen_string_literal: true
 
+module BlacklightMaps
   # Parent class of geospatial objects used in BlacklightMaps
   class Geometry
-
     # This class contains Bounding Box objects and methods for interacting with
     # them.
     class BoundingBox
-
       # points is an array containing longitude and latitude values which
       # relate to the southwest and northeast points of a bounding box
-      # [west, south, east, north] ([swlng, swlat, nelng, nelat]).
+      # [west, south, east, north] ([minX, minY, maxX, maxY]).
       def initialize(points)
         @west = points[0].to_f
         @south = points[1].to_f
@@ -17,15 +16,24 @@ module BlacklightMaps
         @north = points[3].to_f
       end
 
+      def geojson_geometry_array
+        [
+          [
+            [@west, @south],
+            [@east, @south],
+            [@east, @north],
+            [@west, @north],
+            [@west, @south]
+          ]
+        ]
+      end
+
       # Returns an array [lng, lat] which is the centerpoint of a BoundingBox.
       def find_center
         center = []
         center[0] = (@west + @east) / 2
         center[1] = (@south + @north) / 2
-
-        # Handle bounding boxes that cross the dateline
-        center[0] -= 180 if @west > @east
-
+        center[0] -= 180 if @west > @east # handle bboxes that cross the dateline
         center
       end
 
@@ -34,11 +42,21 @@ module BlacklightMaps
       def self.from_lon_lat_string(points)
         new(points.split(' '))
       end
+
+      # Creates a new bounding box from from a Solr WKT Envelope string
+      # "ENVELOPE(34.26, 35.89, 33.33, 29.47)" (minX, maxX, maxY, minY)
+      def self.from_wkt_envelope(envelope)
+        coords = envelope.gsub(/[[A-Z]\(\)]/, '')&.split(', ')
+        new([coords[0], coords[3], coords[1], coords[2]])
+      end
+
+      def to_a
+        [@west, @south, @east, @north]
+      end
     end
 
     # This class contains Point objects and methods for working with them
     class Point
-
       # points is an array corresponding to the longitude and latitude values
       # [long, lat]
       def initialize(points)
@@ -49,13 +67,9 @@ module BlacklightMaps
       # returns a string that can be used as the value of solr_parameters[:pt]
       # normalizes any long values >180 or <-180
       def normalize_for_search
-        case
-          when @long > 180
-            @long -= 360
-          when @long < -180
-            @long += 360
-        end
-        [@long,@lat]
+        @long -= 360 if @long > 180
+        @long += 360 if @long < -180
+        [@long, @lat]
       end
 
       # Creates a new point from from a coordinate string
@@ -63,8 +77,6 @@ module BlacklightMaps
       def self.from_lat_lon_string(points)
         new(points.split(',').reverse)
       end
-
     end
-
   end
 end