Merge pull request #2651 from sciencehistory/export_csv_from_cart

CSV report from cart

Author: jrochkind

app/controllers/admin/cart_items_controller.rb

@@ -1,5 +1,7 @@
 class Admin::CartItemsController < AdminController
   before_action :authenticate_user! # need to be logged in
+  require 'csv'
+
 
   # GET /admin/cart_items
   # GET /admin/cart_items.json
@@ -69,4 +71,13 @@ def clear
     redirect_to admin_cart_items_url, notice: "emptied cart"
   end
 
+  def report
+    begin
+      serializer = WorkCartSerializer.new(current_user.works_in_cart)
+      output_csv_file = serializer.csv_tempfile
+      send_file output_csv_file.path, filename: "cart-report-#{Date.today.to_s}.csv"
+    ensure
+      output_csv_file.close
+    end
+  end
 end

app/serializers/work_cart_serializer.rb

@@ -0,0 +1,167 @@
+# Serializes one work to a hash, or a Tempfile.new containing CSV info
+#
+# The serializer will use these associations, so they should be eager-loaded:
+# * leaf_representative
+# * contained_by (collection)
+#
+# serializer = WorkCartSerializer.new(columns)
+# serializer.row(work) # returns an array you can use in a report.
+
+class WorkCartSerializer
+
+  def initialize(scope, columns: nil, extra_separator: '|')
+    @scope = scope
+    @extra_separator = extra_separator
+    @column_keys = if columns.nil?
+      all_columns.keys
+    else
+      columns.select { |c| all_columns.keys.include? c }
+    end
+  end
+
+  # Does not close the tempfile - that's your responsibility.
+  def csv_tempfile
+    output_csv_file = Tempfile.new
+    CSV.open(output_csv_file, "wb") do |csv|
+      self.to_a.each { |row| csv << row }
+    end
+    output_csv_file
+  end
+
+  def to_a
+    data = []
+    data << title_row
+    @scope.includes(:leaf_representative, :contained_by).find_each do |work|
+      data << row(work)
+    end
+    data
+  end
+
+  def title_row
+    @column_keys.map {|k| all_columns[k]}
+  end
+
+  def row(work)
+    @column_keys.map do |k|
+      column_to_string(
+        column_methods[k].call(work)
+      )
+    end
+  end
+
+  # A hash of possible columns (and their titles)
+  # you can use in the report.
+  # By default, the report contains all these columns,
+  # but you can pass `columns` to return fewer.
+  def all_columns
+    @all_columns ||= {
+      title:                    'Title',
+      additional_title:         'Additional title',
+      url:                      'URL',
+      external_id:              'External ID',
+      department:               'Department',
+      creator:                  'Creator',
+      date:                     'Date',
+      medium:                   'Medium',
+      extent:                   'Extent',
+      place:                    'Place',
+      genre:                    'Genre',
+      description:              'Description',
+      subject:                  'Subject/s',
+      series_arrangement:       'Series Arrangement',
+      physical_container:       'Physical Container',
+      collection:               'Collection',
+      rights:                   'Rights',
+      rights_holder:            'Rights Holder',
+      additional_credit:        'Additional Credit',
+      digitization_funder:      'Digitization Funder',
+      admin_note:               'Admin Note',
+      created:                  'Created',
+      last_modified:            'Last Modified'
+    }
+  end
+
+  # Returns a hash.
+  # The keys of the hash are the same as @column_keys .
+  # The values of the hash are procs.
+  #
+  # Each proc
+  #   takes the work as an argument and
+  #   returns the metadata we want.
+  #
+  # { :title => method(work), :additional_title => method(work), ... }
+  def column_methods
+    @column_methods ||= @column_keys.map do |column_label|
+    
+      # create the proc
+      new_proc = if self.respond_to? column_label
+        # If k is defined in this class, use that (e.g. :created)
+        Proc.new { |some_work| self.send column_label, some_work }
+      elsif Work.method_defined? column_label
+        # Or, if k is defined as a method on work, use that (e.g. :title)
+        Proc.new { |some_work| some_work.send column_label }
+      else
+        raise "Unknown column: #{column_label}"
+      end
+    
+      [column_label, new_proc]
+    end.to_h
+  end
+
+  def column_to_string(arr_or_string)
+    return '' if arr_or_string.nil?
+    return arr_or_string.join(@extra_separator) if arr_or_string.is_a?(Array)
+    arr_or_string
+  end
+
+  def url(work)
+    app_url_base + Rails.application.routes.url_helpers.work_path(work.friendlier_id)
+  end
+
+  def external_id(work)
+    work.external_id.map(&:value)
+  end
+
+  def creator(work)
+    work.creator.map(&:value)
+  end
+
+  def place(work)
+    work.place.map(&:value)
+  end
+
+  def collection(work)
+    work.contained_by.map(&:title)
+  end
+
+  def date(work)
+    DateDisplayFormatter.new(work.date_of_work).display_dates
+  end
+
+  def description(work)
+    DescriptionDisplayFormatter.new(work.description).format_plain
+  end
+
+  def physical_container(work)
+    return nil if work.physical_container.nil?
+    work.physical_container.attributes.map {|l, v | "#{l.humanize}: #{v}" if v.present? }.compact
+  end
+
+  def additional_credit(work)
+     work.additional_credit.map{ |item| "#{item.role}:#{item.name}" }
+  end
+
+  def created(work)
+    I18n.l work.created_at, format: :admin
+  end
+
+  def last_modified(work)
+    I18n.l work.updated_at, format: :admin
+  end
+
+  protected
+
+  def app_url_base
+    @app_url_base ||= ScihistDigicoll::Env.lookup!(:app_url_base)
+  end
+end

app/views/admin/cart_items/index.html.erb

@@ -3,6 +3,7 @@
 <div class="d-flex justify-content-between">
   <p>
     <%= link_to "Batch Edit", batch_update_admin_works_path, class: "btn btn-primary" %>
+    <%= link_to "Save a report", report_admin_cart_items_path, class: "btn btn-primary", data: { confirm: "Save a CSV report?"}, method: "post" %>
     <%= link_to "Clear Cart", clear_admin_cart_items_path, class: "btn btn-outline-danger", data: { confirm: "Delete all items in cart?"}, method: "delete" %>
   </p>
 

config/routes.rb

@@ -329,9 +329,10 @@ def self.matches?(request)
       to: "digitization_queue_items#delete_comment",
       as: "delete_digitization_queue_item_comment"
 
-    resources :cart_items, param: :work_friendlier_id, only: [:index, :update, :destroy] do
+    resources :cart_items, param: :work_friendlier_id, only: [:index, :update, :destroy, :report] do
       collection do
         delete 'clear'
+        post 'report'
       end
     end
 

spec/controllers/admin/cart_items_controller_spec.rb

@@ -0,0 +1,22 @@
+require 'rails_helper'
+RSpec.describe Admin::CartItemsController, :logged_in_user, type: :controller, queue_adapter: :test do
+  context "smoke test for report" do
+    # See also the test for the cart_exporter itself at 
+    # at spec/services/cart_exporter_spec.rb
+    let(:work_1) { FactoryBot.create(:work, :with_assets)}
+    let(:work_2) { FactoryBot.create(:work, :with_assets)}
+    let(:work_3) { FactoryBot.create(:work, :with_assets)}
+	  before do
+	    controller.current_user.works_in_cart = [work_1, work_2, work_3]
+	  end
+
+    it "export smoke test" do
+      post :report
+      expect(response.status).to eq(200)
+      expect(response.headers["Content-Type"]).
+        to eq 'text/csv'
+      expect(response.headers["Content-Disposition"]).
+        to match %r{attachment; filename=\"cart-report-.*.csv\"}
+    end     
+  end
+end

spec/serializers/work_cart_serializer_spec.rb

@@ -0,0 +1,76 @@
+require 'rails_helper'
+
+describe WorkCartSerializer do
+  let(:scope) { Work.all.includes(:leaf_representative, :contained_by) }
+  let(:report) { WorkCartSerializer.new(scope).to_a }
+
+  context "smoke test with two works" do
+    let!(:work_1) { create(:public_work, title: "Title of work 1") }
+    let!(:work_2) { create(:public_work, title: "Title of work 2") }
+    it "returns a report with correct titles and one row per work" do
+      expect(report[0]).to eq [
+        "Title", "Additional title",
+        "URL", "External ID", "Department", "Creator",
+        "Date", "Medium", "Extent", "Place", "Genre",
+        "Description", "Subject/s", "Series Arrangement",
+        "Physical Container", "Collection", "Rights",
+        "Rights Holder", "Additional Credit",
+        "Digitization Funder", "Admin Note",
+        "Created", "Last Modified"
+      ]
+      expect(report.length).to eq 3
+    end
+  end
+
+  context "work with all metadata in it" do
+    let!(:work_1) { create(:public_work, :with_complete_metadata, :with_collection,
+        place_attributes: {"0"=>{"category"=> "place_of_creation", "value"=>"Illinois--Peoria"}},
+        subject: ['s1', 's2', 's3'],
+    ) }
+    it "values are correct; all columns present" do
+      expect(report.length).to eq 2
+      expect(report[1][0]).to  eq 'Test title'
+      expect(report[1][1]).to  eq 'Additional Title 1|Additional Title 2'
+      expect(report[1][2]).to  match /http.*works/
+      expect(report[1][3]).to  eq 'Past Perfect ID 1|Sierra Bib Number 1|Sierra Bib Number 2|Accession Number 1'
+      expect(report[1][4]).to  eq 'Center for Oral History'
+      expect(report[1][5]).to  eq 'After 1|Author 1|Contributor 1'
+      expect(report[1][6]).to  eq 'Before 2014-Jan-01 – circa 2014-Jan-02 (Note 1)|Before 2014-Feb-03 – circa 2014-Feb-04 (Note 2)|Before 2014-Mar-05 – circa 2014-Mar-06 (Note 3)'
+      expect(report[1][7]).to  eq 'Audiocassettes|Celluloid|Dye'
+      expect(report[1][8]).to  eq '0.75 in. H x 2.5 in. W|80 cm L x 22 cm Diam.'
+      expect(report[1][9]).to  eq 'Illinois--Peoria'    # place
+      expect(report[1][10]).to eq 'Lithographs'         # genre
+      expect(report[1][11]).to eq 'Description 1'       # description
+      expect(report[1][12]).to eq 's1|s2|s3'            # subject
+      expect(report[1][13]).to eq 'Series arrangement 1|Series arrangement 2'
+      expect(report[1][14]).to eq 'Box: Box|Page: Page|Part: Part|Reel: Reel|Folder: Folder|Volume: Volume|Shelfmark: Shelfmark'
+      expect(report[1][15]).to eq 'Test title' # collection
+      expect(report[1][16]).to eq "http://rightsstatements.org/vocab/NoC-US/1.0/"
+      expect(report[1][17]).to eq "Rights Holder"
+      expect(report[1][18]).to eq "photographed_by:Douglas Lockard|photographed_by:Mark Backrath"
+      expect(report[1][19]).to eq "Daniel Sanford"
+      expect(report[1][20]).to eq "Admin Note"
+      expect(Date.parse(report[1][21])).to be_a Date
+      expect(Date.parse(report[1][22])).to be_a Date
+    end
+  end
+
+  context "do not include child works; respect order of columns" do
+    let!(:parent) { create(:public_work,
+        title: "The parent",
+        members: [child],
+        creator_attributes: {
+          "0"=>{"category"=> "author",    "value"=>"creator1"},
+          "1"=>{"category"=> "publisher", "value" => "publisher1 " }
+          },
+        )
+    }
+    let(:child) { create(:public_work, title: "child title") }
+    let(:scope) { Work.where(title: 'The parent') }
+    let(:report) { WorkCartSerializer.new(scope, columns: [:creator, :title]).to_a }
+    it "returns a report" do
+      expect(report).to match_array([["Creator", "Title"], ["creator1|publisher1 ", "The parent"]])
+    end
+  end
+
+end