geoblacklight_admin 0.0.1

data/app/controllers/admin/document_assets_controller.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+# Admin::DocumentAssetsController
+module Admin
+  class DocumentAssetsController < Admin::AdminController
+    before_action :set_document
+
+    def index
+      scope = Kithe::Asset
+
+      # simple simple search on a few simple attributes with OR combo.
+      if params[:document_id].present?
+        document = Document.find_by_friendlier_id(params[:document_id])
+        scope = scope.where(parent_id: document.id)
+      end
+
+      # scope = scope.page(params[:page]).per(20).order(created_at: :desc)
+      scope = scope.includes(:parent)
+
+      @document_assets = scope
+    end
+
+    def show
+      @asset = Kithe::Asset.find_by_friendlier_id!(params[:id])
+      authorize! :read, @asset
+
+      if @asset.stored?
+        @checks = @asset.fixity_checks.order("created_at asc")
+        @latest_check = @checks.last
+        @earliest_check = @checks.first
+      end
+    end
+
+    def edit
+      @asset = Kithe::Asset.find_by_friendlier_id!(params[:id])
+      authorize! :update, @asset
+    end
+
+    # PATCH/PUT /works/1
+    # PATCH/PUT /works/1.json
+    def update
+      @asset = Kithe::Asset.find_by_friendlier_id!(params[:id])
+      authorize! :update, @asset
+
+      respond_to do |format|
+        if @asset.update(asset_params)
+          format.html { redirect_to admin_asset_url(@asset), notice: "Asset was successfully updated." }
+          format.json { render :show, status: :ok, location: @asset }
+        else
+          format.html { render :edit }
+          format.json { render json: @asset.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def destroy
+      @asset = Kithe::Asset.find_by_friendlier_id!(params[:id])
+      @asset.destroy
+
+      respond_to do |format|
+        format.html { redirect_to document_document_assets_path(@document), notice: "Asset '#{@asset.title}' was successfully destroyed." }
+        format.json { head :no_content }
+      end
+    end
+
+    def check_fixity
+      @asset = Kithe::Asset.find_by_friendlier_id!(params[:asset_id])
+      SingleAssetCheckerJob.perform_later(@asset)
+      redirect_to admin_asset_url(@asset), notice: "This file will be checked shortly."
+    end
+
+    def fixity_report
+      @fixity_report = FixityReport.new
+    end
+
+    def display_attach_form
+      @document = Document.find_by_friendlier_id!(params[:document_id])
+    end
+
+    # Receives json hashes for direct uploaded files in params[:files],
+    # and id in params[:id] (friendlier_id)
+    # creates filesets for them and attach.
+    #
+    # POST /document/:id/ingest
+    def attach_files
+      @parent = Document.find_by_friendlier_id!(params[:id])
+
+      current_position = @parent.members.maximum(:position) || 0
+
+      files_params = (params[:cached_files] || [])
+        .collect { |s| JSON.parse(s) }
+        .sort_by { |h| h&.dig("metadata", "filename") }
+
+      files_params.each do |file_data|
+        asset = Kithe::Asset.new
+
+        # if derivative_storage_type = params.dig(:storage_type_for, file_data["id"])
+        #  asset.derivative_storage_type = derivative_storage_type
+        # end
+
+        asset.position = (current_position += 1)
+        asset.parent_id = @parent.id
+        asset.file = file_data
+        asset.title = (asset.file&.original_filename || "Untitled")
+        asset.save!
+      end
+
+      if @parent.representative_id.nil?
+        @parent.update(representative: @parent.members.order(:position).first)
+      end
+
+      redirect_to document_path(@parent.friendlier_id, anchor: "nav-members")
+    end
+
+    def convert_to_child_work
+      @asset = Kithe::Asset.find_by_friendlier_id!(params[:id])
+
+      parent = @asset.parent
+
+      new_child = Work.new(title: @asset.title)
+
+      # Asking for permission to create a new Work,
+      # which is arguably the main thing going on in this method.
+      # authorize! :create, Work as the first line of the method
+      # would be better, but we currently aren't allowed to do that
+      # see (https://github.com/chaps-io/access-granted/pull/56).
+      authorize! :create, new_child
+
+      new_child.parent = parent
+      # collections
+      new_child.contained_by = parent.contained_by
+      new_child.position = @asset.position
+      new_child.representative = @asset
+      # we can copy _all_ the non-title metadata like this...
+      new_child.json_attributes = parent.json_attributes
+
+      @asset.parent = new_child
+
+      Kithe::Model.transaction do
+        new_child.save!
+        @asset.save! # to get new parent
+
+        if parent.representative_id == @asset.id
+          parent.representative = new_child
+          parent.save!
+        end
+      end
+
+      redirect_to edit_admin_work_path(new_child), notice: "Asset promoted to child work #{new_child.title}"
+    end
+
+    # requires params[:active_encode_status_id]
+    def refresh_active_encode_status
+      status = ActiveEncodeStatus.find(params[:active_encode_status_id])
+
+      RefreshActiveEncodeStatusJob.perform_later(status)
+
+      redirect_to admin_asset_url(status.asset), notice: "Started refresh for ActiveEncode job #{status.active_encode_id}"
+    end
+
+    def work_is_oral_history?
+      (@asset.parent.is_a? Work) && @asset.parent.genre && @asset.parent.genre.include?("Oral histories")
+    end
+    helper_method :work_is_oral_history?
+
+    def asset_is_collection_thumbnail?
+      @asset.parent.is_a? Collection
+    end
+    helper_method :asset_is_collection_thumbnail?
+
+    def edit_path(asset)
+      asset.parent.is_a? Collection ? edit_admin_collection_path(asset.parent) : edit_admin_asset_path(asset)
+    end
+    helper_method :edit_path
+
+    def parent_path(asset)
+      return nil if asset.parent.nil?
+      asset.parent.is_a? Collection ? collection_path(asset.parent) : admin_work_path(asset.parent)
+    end
+    helper_method :parent_path
+
+    private
+
+    def set_document
+      return unless params[:document_id] # If not nested
+
+      @document = Document.includes(:leaf_representative).find_by!(friendlier_id: params[:document_id])
+    end
+
+    def asset_params
+      allowed_params = [:title, :derivative_storage_type, :alt_text, :caption,
+        :transcription, :english_translation,
+        :role, {admin_note_attributes: []}]
+      allowed_params << :published if can?(:publish, @asset)
+      params.require(:asset).permit(*allowed_params)
+    end
+  end
+end

data/app/controllers/admin/document_downloads_controller.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# Admin::DocumentDownloadsController
+module Admin
+  class DocumentDownloadsController < Admin::AdminController
+    before_action :set_document
+    before_action :set_document_download, only: %i[show edit update destroy]
+
+    # GET /document_downloads or /document_downloads.json
+    def index
+      @document_downloads = DocumentDownload.all
+      if params[:document_id]
+        @document_downloads = DocumentDownload.where(friendlier_id: @document.friendlier_id).order(position: :asc)
+      else
+        @pagy, @document_downloads = pagy(DocumentDownload.all.order(friendlier_id: :asc, updated_at: :desc), items: 20)
+      end
+    end
+
+    # GET /document_downloads/1 or /document_downloads/1.json
+    def show
+    end
+
+    # GET /document_downloads/new
+    def new
+      @document_download = DocumentDownload.new
+    end
+
+    # GET /document_downloads/1/edit
+    def edit
+    end
+
+    # POST /document_downloads or /document_downloads.json
+    def create
+      @document_download = DocumentDownload.new(document_download_params)
+
+      logger.debug("DD Params: #{DocumentDownload.new(document_download_params).inspect}")
+      logger.debug("Document DOWNLOAD: #{@document_download.inspect}")
+
+      respond_to do |format|
+        if @document_download.save
+          format.html do
+            redirect_to document_document_downloads_path(@document_download.document), notice: "Document download was successfully created."
+          end
+          format.json { render :show, status: :created, location: @document_download }
+        else
+          format.html { render :new, status: :unprocessable_entity }
+          format.json { render json: @document_download.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /document_downloads/1 or /document_downloads/1.json
+    def update
+      respond_to do |format|
+        if @document_download.update(document_download_params)
+          format.html do
+            redirect_to document_document_downloads_path(@document_download.document), notice: "Document download was successfully updated."
+          end
+          format.json { render :show, status: :ok, location: @document_download }
+        else
+          format.html { render :edit, status: :unprocessable_entity }
+          format.json { render json: @document_download.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /document_downloads/1 or /document_downloads/1.json
+    def destroy
+      @document_download.destroy
+
+      respond_to do |format|
+        format.html { redirect_to document_downloads_url, notice: "Document download was successfully destroyed." }
+        format.json { head :no_content }
+      end
+    end
+
+    def destroy_all
+      logger.debug("Destroy Downloads")
+      return unless params.dig(:document_download, :downloads, :file)
+
+      respond_to do |format|
+        if DocumentDownload.destroy_all(params.dig(:document_download, :downloads, :file))
+          format.html { redirect_to document_downloads_path, notice: "Download Links were created destroyed." }
+        else
+          format.html { redirect_to document_downloads_path, notice: "Download Links could not be destroyed." }
+        end
+      rescue => e
+        format.html { redirect_to document_downloads_path, notice: "Download Links could not be destroyed. #{e}" }
+      end
+    end
+
+    # GET   /documents/#id/downloads/import
+    # POST  /documents/#id/downloads/import
+    def import
+      logger.debug("Import Downloads")
+      return unless params.dig(:document_download, :downloads, :file)
+
+      respond_to do |format|
+        if DocumentDownload.import(params.dig(:document_download, :downloads, :file))
+          format.html { redirect_to document_downloads_path, notice: "Download Links were created successfully." }
+        else
+          format.html { redirect_to document_downloads_path, notice: "Download Links could not be created." }
+        end
+      rescue => e
+        format.html { redirect_to document_downloads_path, notice: "Download Links could not be created. #{e}" }
+      end
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_document
+      return unless params[:document_id] # If not nested
+
+      @document = Document.includes(:leaf_representative).find_by!(friendlier_id: params[:document_id])
+    end
+
+    def set_document_download
+      @document_download = DocumentDownload.find(params[:id])
+    end
+
+    # Only allow a list of trusted parameters through.
+    def document_download_params
+      params.require(:document_download).permit(:friendlier_id, :label, :value, :position)
+    end
+  end
+end

data/app/controllers/admin/documents_controller.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+# Admin::DocumentsController
+module Admin
+  class DocumentsController < Admin::AdminController
+    ActionController::Parameters.permit_all_parameters = true
+    before_action :set_document,
+      only: %i[show edit update destroy versions]
+
+    # GET /documents
+    # GET /documents.json
+    def index
+      query_params = {
+        q: params["q"],
+        f: params["f"],
+        page: params["page"],
+        rows: params["rows"] || 20,
+        sort: params["sort"] || "score desc",
+        daterange: params["daterange"] || nil
+      }
+      @documents = BlacklightApi.new(**query_params)
+
+      respond_to do |format|
+        format.html { render :index }
+        format.json { render json: @documents.results.to_json }
+
+        # JSON - BTAA Aardvark
+        format.json_btaa_aardvark do
+          ExportJsonJob.perform_later(current_user, query_params.merge!({format: "json_btaa_aardvark"}), ExportJsonService)
+          head :no_content
+        end
+
+        # JSON - GBL Aardvark
+        format.json_aardvark do
+          ExportJsonJob.perform_later(current_user, query_params.merge!({format: "json_aardvark"}), ExportJsonService)
+          head :no_content
+        end
+
+        # JSON - GBL v1
+        format.json_gbl_v1 do
+          ExportJsonJob.perform_later(current_user, query_params.merge!({format: "json_gbl_v1"}), ExportJsonService)
+          head :no_content
+        end
+
+        # CSV - B1G
+        format.csv do
+          ExportJob.perform_later(current_user, query_params, ExportCsvService)
+          head :no_content
+        end
+
+        # CSV Document Downloads - B1G
+        format.csv_document_downloads do
+          ExportJob.perform_later(current_user, query_params, ExportCsvDocumentDownloadsService)
+          head :no_content
+        end
+
+        # CSV Document Access Links - B1G
+        format.csv_document_access_links do
+          ExportJob.perform_later(current_user, query_params, ExportCsvDocumentAccessLinksService)
+          head :no_content
+        end
+      end
+    end
+
+    # Fetch documents from array of friendlier_ids
+    def fetch
+      @documents = Document.where(friendlier_id: params["ids"])
+
+      respond_to do |format|
+        format.html { render :index }
+        format.json { render json: @documents.to_json }
+
+        # JSON - BTAA Aardvark
+        format.json_btaa_aardvark do
+          ExportJsonJob.perform_later(current_user, {ids: @documents.pluck(:friendlier_id), format: "json_btaa_aardvark"},
+            ExportJsonService)
+          head :no_content
+        end
+
+        # JSON - GBL Aardvark
+        format.json_aardvark do
+          ExportJsonJob.perform_later(current_user, {ids: @documents.pluck(:friendlier_id), format: "json_aardvark"}, ExportJsonService)
+          head :no_content
+        end
+
+        # JSON - GBL v1
+        format.json_gbl_v1 do
+          ExportJsonJob.perform_later(current_user, {ids: @documents.pluck(:friendlier_id), format: "json_gbl_v1"}, ExportJsonService)
+          head :no_content
+        end
+
+        # CSV - B1G
+        format.csv do
+          ExportJob.perform_later(current_user, {ids: @documents.pluck(:friendlier_id), format: "csv"}, ExportCsvService)
+          head :no_content
+        end
+
+        # CSV Document Downloads - B1G
+        format.csv_document_downloads do
+          ExportJob.perform_later(current_user, {ids: @documents.pluck(:friendlier_id), format: "csv_document_downloads"}, ExportCsvDocumentDownloadsService)
+          head :no_content
+        end
+
+        # CSV Document Downloads - B1G
+        format.csv_document_access_links do
+          ExportJob.perform_later(current_user, {ids: @documents.pluck(:friendlier_id), format: "csv_document_access_links"}, ExportCsvDocumentAccessLinksService)
+          head :no_content
+        end
+      end
+    end
+
+    # GET /documents/new
+    def new
+      @document = Document.new
+      render :edit
+    end
+
+    # GET /documents/1/edit
+    def edit
+    end
+
+    # GET /documents/1/versions
+    def versions
+    end
+
+    # POST /documents
+    # POST /documents.json
+    def create
+      @document = Document.new(document_params)
+      @document.friendlier_id = @document.send(GeoblacklightAdmin::Schema.instance.solr_fields[:id])
+      respond_to do |format|
+        if @document.save
+          format.html { redirect_to admin_documents_path, notice: "Document was successfully created." }
+          format.json { render :show, status: :created, location: @document }
+        else
+          format.html { render :edit }
+          format.json { render json: @document.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /documents/1
+    # PATCH/PUT /documents/1.json
+    def update
+      respond_to do |format|
+        if @document.update(document_params)
+          format.html { redirect_to edit_admin_document_path(@document), notice: "Document was successfully updated." }
+          format.json { render :show, status: :ok, location: @document }
+        else
+          format.html { render :edit }
+          format.json { render json: @document.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /documents/1
+    # DELETE /documents/1.json
+    def destroy
+      @document.destroy
+      respond_to do |format|
+        format.html { redirect_to admin_documents_url, notice: "Document '#{@document.title}' was successfully destroyed." }
+        format.json { head :no_content }
+      end
+    end
+
+    def show
+      respond_to do |format|
+        format.html { redirect_to edit_admin_document_url(@document) }
+        format.json { render json: @document.to_json } # App-style JSON
+        format.json_aardvark
+        format.json_btaa_aardvark
+        format.json_gbl_v1
+        # B1G CSV
+        format.csv { send_data collect_csv([@document]), filename: "documents-#{Time.zone.today}.csv" }
+
+        # @TODO:
+        # geoblacklight_version: 1.0 (strict)
+        # geoblacklight_version: 1.0 + B1G customizations
+        # geoblacklight_version: 2.0 (strict)
+        # geoblacklight_version: 2.0 + B1G customizations
+      end
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_document
+      @document = Document.includes(:leaf_representative).find_by!(friendlier_id: params[:id] || params[:document_id])
+    end
+
+    # only allow whitelisted params through (TODO, we're allowing all document params!)
+    # Plus sanitization or any other mutation.
+    #
+    # This could be done in a form object or otherwise abstracted, but this is good
+    # enough for now.
+    def permittable_params
+      %i[title publication_state layer_geom_type_s dct_references_s q f page sort rows daterange]
+    end
+
+    def document_params
+      Kithe::Parameters.new(params).require(:document).permit_attr_json(Document).permit(permittable_params)
+    end
+
+    def collect_csv(documents)
+      CSV.generate(headers: true) do |csv|
+        csv << GeoblacklightAdmin::Schema.instance.exportable_fields.map { |k, _v| k.to_s }
+        if documents.instance_of?(BlacklightApi)
+          documents.load_all.map do |doc|
+            csv << doc.to_csv if doc.present?
+          end
+        else
+          documents.each do |doc|
+            csv << doc.to_csv
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/admin/elements_controller.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Admin::ElementsController
+module Admin
+  class ElementsController < Admin::AdminController
+    before_action :set_element, only: %i[show edit update destroy]
+
+    # GET /elements or /elements.json
+    def index
+      @pagy, @elements = pagy(Element.all.order(position: :asc), items: 100)
+    end
+
+    # GET /elements/1 or /elements/1.json
+    def show
+    end
+
+    # GET /elements/new
+    def new
+      @element = Element.new
+    end
+
+    # GET /elements/1/edit
+    def edit
+    end
+
+    # POST /elements or /elements.json
+    def create
+      @element = Element.new(element_params)
+
+      respond_to do |format|
+        if @element.save
+          format.html { redirect_to element_url(@element), notice: "Element was successfully created." }
+          format.json { render :show, status: :created, location: @element }
+        else
+          format.html { render :new, status: :unprocessable_entity }
+          format.json { render json: @element.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /elements/1 or /elements/1.json
+    def update
+      respond_to do |format|
+        if @element.update(element_params)
+          format.html { redirect_to element_url(@element), notice: "Element was successfully updated." }
+          format.json { render :show, status: :ok, location: @element }
+        else
+          format.html { render :edit, status: :unprocessable_entity }
+          format.json { render json: @element.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /elements/1 or /elements/1.json
+    def destroy
+      @element.destroy
+
+      respond_to do |format|
+        format.html { redirect_to elements_url, notice: "Element was successfully destroyed." }
+        format.json { head :no_content }
+      end
+    end
+
+    def sort
+      Element.sort_elements(params[:id_list])
+      render body: nil
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_element
+      @element = Element.find(params[:id])
+    end
+
+    # Only allow a list of trusted parameters through.
+    def element_params
+      params.require(:element).permit(:label, :solr_field, :field_definition, :field_type, :required, :repeatable, :formable, :placeholder_text, :data_entry_hint, :test_fixture_example, :controlled_vocabulary, :js_behaviors, :html_attributes, :display_only_on_persisted, :importable, :import_deliminated, :import_transformation_method, :exportable, :export_transformation_method, :indexable, :index_transformation_method, :validation_method, :position)
+    end
+  end
+end

data/app/controllers/admin/form_elements_controller.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Admin::FormElementsController
+module Admin
+  class FormElementsController < Admin::AdminController
+    before_action :set_form_element, only: %i[show edit update destroy]
+
+    # GET /form_elements or /form_elements.json
+    def index
+      @form_elements = FormElement.all
+    end
+
+    # GET /form_elements/1 or /form_elements/1.json
+    def show
+    end
+
+    # GET /form_elements/new
+    def new
+      @form_element = FormElement.new
+    end
+
+    # GET /form_elements/1/edit
+    def edit
+    end
+
+    # POST /form_elements or /form_elements.json
+    def create
+      @form_element = FormElement.new(form_element_params)
+
+      respond_to do |format|
+        if @form_element.save
+          format.html { redirect_to form_elements_path, notice: "Form element was successfully created." }
+          format.json { render :show, status: :created, location: @form_element }
+        else
+          format.html { render :new, status: :unprocessable_entity }
+          format.json { render json: @form_element.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /form_elements/1 or /form_elements/1.json
+    def update
+      respond_to do |format|
+        if @form_element.update(form_element_params)
+          format.html { redirect_to form_element_url(@form_element), notice: "Form element was successfully updated." }
+          format.json { render :show, status: :ok, location: @form_element }
+        else
+          format.html { render :edit, status: :unprocessable_entity }
+          format.json { render json: @form_element.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /form_elements/1 or /form_elements/1.json
+    def destroy
+      @form_element.destroy
+
+      respond_to do |format|
+        format.html { redirect_to form_elements_url, notice: "Form element was successfully destroyed." }
+        format.json { head :no_content }
+      end
+    end
+
+    def sort
+      FormElement.sort_elements(params[:id_list])
+      render body: nil
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_form_element
+      @form_element = FormElement.find(params[:id])
+    end
+
+    # Only allow a list of trusted parameters through.
+    def form_element_params
+      params.require(:form_element).permit(:type, :label, :element_solr_field)
+    end
+  end
+end