geoblacklight 6.0.0.pre.alpha.4 → 6.0.0.pre.alpha.5

data/app/components/geoblacklight/download_links_component.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  # Display expandable file download links in sidebar
-  class DownloadLinksComponent < ViewComponent::Base
-    attr_reader :document
-
-    def initialize(document:)
-      @document = document
-      super()
-    end
-
-    def render?
-      downloadable? && (document.direct_download.present? || document.iiif_download.present? || document.download_types.present?)
-    end
-
-    def downloadable?
-      helpers.document_available?(@document) && @document.downloadable?
-    end
-
-    def download_link_file(label, id, url)
-      link_to(
-        label,
-        url,
-        "contentUrl" => url,
-        :data => {
-          download: "trigger",
-          download_type: "direct",
-          download_id: id
-        }
-      )
-    end
-
-    # Generates the link markup for the IIIF JPEG download
-    # @return [String]
-    def download_link_iiif
-      link_to(
-        download_text("JPG"),
-        iiif_jpg_url,
-        "contentUrl" => iiif_jpg_url,
-        :data => {
-          download: "trigger"
-        }
-      )
-    end
-
-    def download_link_generated(download_type, document)
-      link_to(
-        t("geoblacklight.download.export_link", download_format: export_format_label(download_type)),
-        "",
-        data: {
-          download_path: download_path(document.id, type: download_type),
-          download: "trigger",
-          action: "downloads#download:once",
-          download_type: download_type,
-          download_id: document.id,
-          download_preparing_message: t("geoblacklight.download.preparing"),
-          download_ready_message: t("geoblacklight.download.ready", type: download_type),
-          download_failed_message: t("geoblacklight.download.failed", type: download_type)
-        }
-      )
-    end
-
-    ##
-    # Wraps download text with proper_case_format
-    #
-    def download_text(format)
-      download_format = proper_case_format(format)
-      value = t("geoblacklight.download.download_link", download_format: download_format)
-      value.html_safe
-    end
-
-    # Format labels are customized for exports - look up the appropriate key.
-    def export_format_label(format)
-      t("geoblacklight.download.export_#{format.to_s.parameterize(separator: "_")}_link")
-    end
-
-    # Looks up properly formatted names for formats
-    def proper_case_format(format)
-      t("geoblacklight.formats.#{format.to_s.parameterize(separator: "_")}")
-    end
-
-    def iiif_jpg_url
-      @document.references.iiif.endpoint.sub! "info.json", "full/full/0/default.jpg"
-    end
-  end
-end

data/app/controllers/download_controller.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-class DownloadController < ApplicationController
-  include Blacklight::Catalog
-
-  rescue_from Geoblacklight::Exceptions::ExternalDownloadFailed do |exception|
-    Geoblacklight.logger.error exception.message + " " + exception.url
-    flash.now[:danger] = view_context
-      .tag.span(t("geoblacklight.download.error"),
-        data: {
-          download: "error",
-          download_id: params[:id],
-          download_type: "generated-#{params[:type]}"
-        })
-    respond_to do |format|
-      format.json { render json: [flash, ""], response: response, status: 500 }
-      format.html { render json: [flash, ""], response: response, status: 500 }
-    end
-  end
-
-  def show
-    @document = search_service.fetch params[:id]
-    restricted_should_authenticate
-    response = check_type
-    validate response
-    respond_to do |format|
-      format.json { render json: [flash, download_file_path(response)], response: response }
-      format.html { render json: [flash, download_file_path(response)], response: response }
-    end
-  end
-
-  def file
-    # Grab the solr document to check if it should be public or not
-    @document = search_service.fetch(file_name_to_id(params[:id]))
-    restricted_should_authenticate
-    send_file download_file_path_and_name, x_sendfile: true
-  end
-
-  private
-
-  def download_file_path_and_name
-    "#{Geoblacklight::Download.file_path}/#{params[:id]}.#{params[:format]}"
-  end
-
-  def check_type
-    case params[:type]
-    when "shapefile"
-      Geoblacklight::ShapefileDownload.new(@document).get
-    when "kmz"
-      Geoblacklight::KmzDownload.new(@document).get
-    when "geojson"
-      Geoblacklight::GeojsonDownload.new(@document).get
-    when "geotiff"
-      Geoblacklight::GeotiffDownload.new(@document).get
-    when "csv"
-      Geoblacklight::CsvDownload.new(@document).get
-    end
-  end
-
-  def validate(response)
-    flash.now[:success] = view_context.link_to(t("geoblacklight.download.success", title: response),
-      download_file_path(response),
-      data: {download: "trigger",
-             download_id: params[:id],
-             download_type: "generated-#{params[:type]}"})
-  end
-
-  # Checks whether a document is public, if not require user to authenticate
-  def restricted_should_authenticate
-    authenticate_user! unless @document.public?
-  end
-
-  def file_name_to_id(file_name)
-    file_name.split("-")[0..-2].join("-")
-  end
-end

data/app/javascript/geoblacklight/controllers/downloads_controller.js

@@ -1,64 +0,0 @@
-import { Controller } from "@hotwired/stimulus"
-
-export default class extends Controller {
-  download(ev) {
-    ev.preventDefault()
-    if (this.downloading) {
-      return
-    }
-    this.downloading = true
-    ev.target.classList.add("download-in-progress")
-    const url = ev.target.dataset.downloadPath
-    ev.target.removeAttribute("href")
-    ev.target.innerHTML = `<div class="spinner-border spinner-border-sm float-end"></div> ${ev.target.dataset.downloadPreparingMessage}`
-
-    fetch(url)
-      .then((response) => {
-        if (!response.ok) {
-          return response.json().then((errorData) => {
-            const exception = new Error("Network response was not ok")
-            exception.data = errorData // Attach the parsed JSON data to the error object
-            throw exception
-          })
-        }
-        return response.json()
-      })
-      .then((data) => this.complete(data, ev.target))
-      .catch((error) => this.error(error, ev.target))
-  }
-
-  complete(data, target) {
-    this.downloading = false
-    target.classList.remove("download-in-progress")
-    target.classList.add("download-complete")
-    target.innerHTML = target.dataset.downloadReadyMessage
-    target.href = data[1]
-    this.renderMessage(data[0])
-    //target.click();
-  }
-
-  error(exception, target) {
-    this.downloading = false
-    target.classList.remove("download-in-progress")
-    target.classList.add("download-complete")
-    target.innerHTML = target.dataset.downloadFailedMessage
-    console.log(exception)
-
-    this.renderMessage(exception.data[0])
-  }
-
-  renderMessage(message) {
-    let flashContainer = document.querySelector("div.flash_messages")
-    if (!flashContainer) {
-      flashContainer = document.createElement("div")
-      flashContainer.className = "flash_messages"
-      document.getElementById("document").prepend(flashContainer)
-    }
-    Object.entries(message).forEach(([idx, msg]) => {
-      const flash = document.createElement("div")
-      flash.className = `alert alert-${msg[0]} alert-dismissible fade show`
-      flash.innerHTML = `${msg[1]}<button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>`
-      flashContainer.appendChild(flash)
-    })
-  }
-}

data/lib/geoblacklight/download/csv_download.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class CsvDownload < Geoblacklight::Download
-    CSV_DOWNLOAD_PARAMS = {service: "wfs",
-                           version: "2.0.0",
-                           request: "GetFeature",
-                           srsName: "EPSG:4326",
-                           outputformat: "csv"}.freeze
-
-    def initialize(document, options = {})
-      request_params = CSV_DOWNLOAD_PARAMS.merge(typeName: document.wxs_identifier)
-      super(document, {
-        type: "csv",
-        extension: "csv",
-        request_params: request_params,
-        content_type: "text/csv",
-        service_type: "wfs"
-      }.merge(options))
-    end
-  end
-end

data/lib/geoblacklight/download/geojson_download.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class GeojsonDownload < Geoblacklight::Download
-    GEOJSON_DOWNLOAD_PARAMS = {
-      service: "wfs",
-      version: "2.0.0",
-      request: "GetFeature",
-      srsName: "EPSG:4326",
-      outputformat: "application/json"
-    }.freeze
-
-    def initialize(document, options = {})
-      request_params = GEOJSON_DOWNLOAD_PARAMS.merge(typeName: document.wxs_identifier)
-      super(document, {
-        type: "geojson",
-        extension: "geojson",
-        request_params: request_params,
-        content_type: "application/json",
-        service_type: "wfs"
-      }.merge(options))
-    end
-  end
-end

data/lib/geoblacklight/download/geotiff_download.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class GeotiffDownload < Geoblacklight::Download
-    GEOTIFF_DOWNLOAD_PARAMS = {
-      format: "image/geotiff",
-      width: 4096
-    }.freeze
-
-    def initialize(document, options = {})
-      request_params = GEOTIFF_DOWNLOAD_PARAMS.merge(layers: document.wxs_identifier)
-      super(document, {
-        type: "geotiff",
-        extension: "tif",
-        request_params: request_params,
-        content_type: "image/geotiff",
-        service_type: "wms",
-        reflect: true
-      }.merge(options))
-    end
-  end
-end

data/lib/geoblacklight/download/kmz_download.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class KmzDownload < Geoblacklight::Download
-    KMZ_DOWNLOAD_PARAMS = {service: "wms",
-                           version: "1.1.0",
-                           request: "GetMap",
-                           srsName: "EPSG:3857",
-                           format: "application/vnd.google-earth.kmz",
-                           width: 2000, height: 2000}.freeze
-
-    def initialize(document, options = {})
-      bbox_wsen = document.geometry.bounding_box
-      request_params = KMZ_DOWNLOAD_PARAMS.merge(layers: document.wxs_identifier, bbox: bbox_wsen)
-      super(document, {
-        type: "kmz",
-        extension: "kmz",
-        request_params: request_params,
-        content_type: "application/vnd.google-earth.kmz",
-        service_type: "wms"
-      }.merge(options))
-    end
-  end
-end

data/lib/geoblacklight/download/shapefile_download.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class ShapefileDownload < Geoblacklight::Download
-    SHAPEFILE_DOWNLOAD_PARAMS = {service: "wfs",
-                                 version: "2.0.0",
-                                 request: "GetFeature",
-                                 srsName: "EPSG:4326",
-                                 outputformat: "SHAPE-ZIP"}.freeze
-
-    def initialize(document, options = {})
-      request_params = SHAPEFILE_DOWNLOAD_PARAMS.merge(typeName: document.wxs_identifier)
-      super(document, {
-        type: "shapefile",
-        extension: "zip",
-        request_params: request_params,
-        content_type: "application/zip",
-        service_type: "wfs"
-      }.merge(options))
-    end
-  end
-end

data/lib/geoblacklight/download.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class Download
-    def initialize(document, options = {})
-      @document = document
-      @options = options
-    end
-
-    def downloadable?
-      @document.downloadable?
-    end
-
-    def file_name
-      "#{@document.id}-#{@options[:type]}.#{@options[:extension]}"
-    end
-
-    def self.file_path
-      Geoblacklight.configuration.download_path
-    end
-
-    def file_path_and_name
-      "#{self.class.file_path}/#{file_name}"
-    end
-
-    def download_exists?
-      File.file?(file_path_and_name)
-    end
-
-    def get
-      if download_exists?
-        file_name
-      else
-        create_download_file
-      end
-    end
-
-    ##
-    # Creates temporary file on file system and renames it if download completes
-    # successfully. Will raise and rescue if the wrong file format is downloaded
-    # @return [String] filename of the completed download
-    def create_download_file
-      download = initiate_download
-
-      File.open("#{file_path_and_name}.tmp", "wb") do |file|
-        fail Geoblacklight::Exceptions::WrongDownloadFormat unless matches_mimetype?(download)
-        file.write download.body
-      end
-      File.rename("#{file_path_and_name}.tmp", file_path_and_name)
-      file_name
-    rescue Geoblacklight::Exceptions::WrongDownloadFormat => error
-      Geoblacklight.logger.error "#{error} expected #{@options[:content_type]} " \
-                                 "received #{download.headers["content-type"]}"
-      File.delete("#{file_path_and_name}.tmp")
-      raise Geoblacklight::Exceptions::ExternalDownloadFailed, message: "Wrong download type"
-    end
-
-    ##
-    # Initiates download from a remote source url using the `request_params`.
-    # Will catch Faraday::ConnectionFailed and
-    # Faraday::TimeoutError
-    # @return [Faraday::Request] returns a Faraday::Request object
-    def initiate_download
-      conn = Faraday.new(url: url)
-      conn.get do |request|
-        request.params = @options[:request_params]
-        request.options.timeout = timeout
-        request.options.open_timeout = timeout
-      end
-    rescue Faraday::ConnectionFailed
-      raise Geoblacklight::Exceptions::ExternalDownloadFailed,
-        message: "Download connection failed",
-        url: conn.url_prefix.to_s
-    rescue Faraday::TimeoutError
-      raise Geoblacklight::Exceptions::ExternalDownloadFailed,
-        message: "Download timed out",
-        url: conn.url_prefix.to_s
-    end
-
-    ##
-    # Creates a download url for the object
-    # @return [String]
-    def url_with_params
-      url + "/?" + URI.encode_www_form(@options[:request_params])
-    end
-
-    private
-
-    def matches_mimetype?(download)
-      MIME::Type.simplified(download.headers["content-type"]) == @options[:content_type]
-    end
-
-    ##
-    # Returns timeout for the download request. `timeout` passed as an option to
-    # the Geoblacklight::Download class
-    # @return [Fixnum] download timeout in seconds
-    def timeout
-      @options[:timeout] || Geoblacklight.configuration.timeout_download
-    end
-
-    ##
-    # URL for download
-    # @return [String] URL that is checked in download
-    def url
-      url = @document.references.public_send(@options[:service_type]).endpoint
-      url += "/reflect" if @options[:reflect]
-      url
-    end
-  end
-end

data/lib/geoblacklight/routes/downloadable.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  module Routes
-    class Downloadable
-      def initialize(defaults = {})
-        @defaults = defaults
-      end
-
-      def call(mapper, _options = {})
-        mapper.get "file/:id", action: "file", as: :file
-      end
-    end
-  end
-end

data/spec/controllers/download_controller_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe DownloadController, type: :controller do
-  describe "#file" do
-    describe "restricted file" do
-      it "redirects to login for authentication" do
-        get :file, params: {id: "stanford-cg357zz0321-shapefile", format: "zip"}
-        expect(response).to have_http_status :unauthorized
-      end
-    end
-    describe "public file" do
-      it "initiates download" do
-        allow(controller).to receive(:render) # Needed for testing with Rails 4
-        expect(controller).to receive(:send_file)
-        get :file, params: {id: "mit-f6rqs4ucovjk2-shapefile", format: "zip"}
-      end
-    end
-  end
-  describe "#show" do
-    describe "restricted file" do
-      it "redirects to login for authentication" do
-        get :show, params: {id: "stanford-cg357zz0321", format: "json"}
-        expect(response).to have_http_status :unauthorized
-      end
-    end
-    describe "public file" do
-      let(:shapefile_download) { instance_double(Geoblacklight::ShapefileDownload) }
-
-      before do
-        allow(Geoblacklight::ShapefileDownload).to receive(:new).and_return(shapefile_download)
-      end
-
-      it "initiates download creation" do
-        allow(shapefile_download).to receive(:get).and_return("success")
-        get :show, params: {id: "mit-f6rqs4ucovjk2", type: "shapefile"}
-        expect(response).to have_http_status :ok
-      end
-    end
-
-    context "when requesting GeoJSON files" do
-      let(:id) { "tufts-cambridgegrid100-04" }
-      let(:type) { "geojson" }
-      let(:geojson_download) { instance_double(Geoblacklight::GeojsonDownload) }
-
-      before do
-        allow(geojson_download).to receive(:get).and_return("file.json")
-        allow(Geoblacklight::GeojsonDownload).to receive(:new).and_return(geojson_download)
-      end
-
-      it "downloads the files and notifies the user" do
-        expect(Geoblacklight::GeojsonDownload).to receive(:new)
-        get :show, params: {id: id, type: type}
-
-        expect(response.body).to include "success"
-        expect(response.body).to include "Your file file.json is ready for download"
-      end
-    end
-
-    context "when requesting GeoTIFF files" do
-      let(:id) { "tufts-cambridgegrid100-04" }
-      let(:type) { "geotiff" }
-      let(:geotiff_download) { instance_double(Geoblacklight::GeotiffDownload) }
-
-      before do
-        allow(geotiff_download).to receive(:get).and_return("file.tiff")
-        allow(Geoblacklight::GeotiffDownload).to receive(:new).and_return(geotiff_download)
-      end
-
-      it "downloads the files and notifies the user" do
-        expect(Geoblacklight::GeotiffDownload).to receive(:new)
-        get :show, params: {id: id, type: type}
-
-        expect(response.body).to include "success"
-        expect(response.body).to include "Your file file.tiff is ready for download"
-      end
-    end
-
-    context "when requesting CSV files" do
-      let(:id) { "tufts-cambridgegrid100-04" }
-      let(:type) { "csv" }
-      let(:csv_download) { instance_double(Geoblacklight::CsvDownload) }
-
-      before do
-        allow(csv_download).to receive(:get).and_return("file.csv")
-        allow(Geoblacklight::CsvDownload).to receive(:new).and_return(csv_download)
-      end
-
-      it "downloads the files and notifies the user" do
-        expect(Geoblacklight::CsvDownload).to receive(:new)
-        get :show, params: {id: id, type: type}
-
-        expect(response.body).to include "success"
-        expect(response.body).to include "Your file file.csv is ready for download"
-      end
-    end
-  end
-end

data/spec/features/download_layer_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "Download layer" do
-  let(:shapefile_download) { instance_double(Geoblacklight::ShapefileDownload) }
-  let(:kmz_download) { instance_double(Geoblacklight::KmzDownload) }
-  let(:csv_download) { instance_double(Geoblacklight::CsvDownload) }
-
-  before do
-    allow(Geoblacklight::ShapefileDownload).to receive(:new).and_return(shapefile_download)
-    allow(Geoblacklight::KmzDownload).to receive(:new).and_return(kmz_download)
-    allow(Geoblacklight::CsvDownload).to receive(:new).and_return(csv_download)
-  end
-
-  # cleanup any downloaded files
-  after do
-    FileUtils.rm("tufts-cambridgegrid100-04-shapefile.zip", force: true)
-    FileUtils.rm("tufts-cambridgegrid100-04-kmz.kmz", force: true)
-  end
-
-  scenario "clicking initial shapefile download button should trigger download", js: true do
-    allow(shapefile_download).to receive(:get).and_return("tufts-cambridgegrid100-04-shapefile.zip")
-    visit solr_document_path("tufts-cambridgegrid100-04")
-    find("#downloads-button").click
-    find('a[data-download-type="shapefile"]', text: "Export Shapefile").click
-    expect(page).to have_css(
-      'a[href="/download/file/tufts-cambridgegrid100-04-shapefile.zip"]',
-      text: "Your file tufts-cambridgegrid100-04-shapefile.zip is ready for download"
-    )
-  end
-
-  scenario "failed download should return message with link to layer", js: true do
-    allow(shapefile_download).to receive(:get).and_raise(Geoblacklight::Exceptions::ExternalDownloadFailed.new(
-      message: "Failed", url: "http://www.example.com/failed"
-    ))
-    visit solr_document_path("mit-f6rqs4ucovjk2")
-    find("#downloads-button").click
-    find('#downloads-collapse a[data-download-type="shapefile"]', text: "Export Shapefile").click
-    expect(page).to have_text "Download failed (shapefile)"
-    expect(page).to have_css "div.alert.alert-danger", text: "Sorry, the requested file could not be downloaded."
-  end
-
-  scenario "clicking kmz download button should trigger download", js: true do
-    allow(kmz_download).to receive(:get).and_return("tufts-cambridgegrid100-04-kmz.kmz")
-    visit solr_document_path("tufts-cambridgegrid100-04")
-    find("#downloads-button").click
-    find('#downloads-collapse a[data-download-type="kmz"]', text: "Export KMZ").click
-    expect(page).to have_css(
-      'a[href="/download/file/tufts-cambridgegrid100-04-kmz.kmz"]',
-      text: "Your file tufts-cambridgegrid100-04-kmz.kmz is ready for download"
-    )
-  end
-
-  scenario "jpg download option should be present under toggle" do
-    visit solr_document_path("princeton-02870w62c")
-    find("#downloads-button").click
-    expect(page).to have_css("#downloads-collapse a", text: "Original JPG")
-  end
-
-  scenario "clicking jpg download button should redirect to external image" do
-    visit solr_document_path("princeton-02870w62c")
-    find("#downloads-button").click
-    expect(page).to have_css(
-      "#downloads-collapse a[href='https://iiif-cloud.princeton.edu/iiif/2/6c%2F52%2F12%2F6c5212e81bc845f59bb1cdc740a88bad%2Fintermediate_file/full/full/0/default.jpg']", text: "Original JPG"
-    )
-  end
-
-  scenario "options should be available under toggle" do
-    visit solr_document_path("tufts-cambridgegrid100-04")
-    find("#downloads-button").click
-    expect(page).to have_css('#downloads-collapse a[data-download-type="shapefile"]', text: "Export Shapefile")
-    expect(page).to have_css('#downloads-collapse a[data-download-type="kmz"]', text: "Export KMZ")
-  end
-
-  scenario "restricted layer should not have download available to non logged in user" do
-    visit solr_document_path("stanford-cg357zz0321")
-    expect(page).to have_css "a", text: "Login to View and Download"
-    expect(page).not_to have_css "button", text: "Download"
-  end
-
-  scenario "restricted layer should have download available to logged in user" do
-    sign_in
-    visit solr_document_path("stanford-cg357zz0321")
-    expect(page).not_to have_css "a", text: "Login to view and download"
-    expect(page).to have_css "button", text: "Download"
-  end
-
-  scenario "layer with direct download and wms/wfs should include all download types" do
-    sign_in
-    visit solr_document_path("stanford-cg357zz0321")
-    find("#downloads-button").click
-    expect(page).to have_css("#downloads-collapse a", text: "Original")
-    expect(page).to have_css("#downloads-collapse a", text: "Export")
-  end
-end