card-mod-carrierwave 0.11.0

data/set/abstract/attachment/upload_cache.rb

@@ -0,0 +1,85 @@
+# action id of the cached upload
+attr_accessor :action_id_of_cached_upload
+
+def actionable?
+  super || preliminary_upload?
+end
+
+event :prepare_attachment, :prepare_to_validate, on: :save, when: :preliminary_upload? do
+  save_original_filename  # save original filename as comment in action
+  write_identifier        # set db_content
+  # (needs original filename to determine extension)
+  store_attachment!
+  store_card_changes
+  # finalize_action         # create Card::Change entry for db_content
+
+  card_id = new_card? ? upload_cache_card.id : id
+  @current_action.update! draft: true, card_id: card_id
+  success << {
+    target: (new_card? ? upload_cache_card : self),
+    type: type_name,
+    view: "preview_editor",
+    rev_id: current_action.id
+  }
+  abort :success
+end
+
+event :assign_attachment_on_create, :initialize,
+      after: :assign_action, on: :create, when: :save_preliminary_upload? do
+  return unless  (action = Card::Action.fetch(@action_id_of_cached_upload))
+  upload_cache_card.selected_action_id = action.id
+  upload_cache_card.select_file_revision
+  assign_attachment upload_cache_card.attachment.file, action.comment
+end
+
+event :assign_attachment_on_update, :initialize,
+      after: :assign_action, on: :update, when: :save_preliminary_upload? do
+  return unless (action = Card::Action.fetch(@action_id_of_cached_upload))
+  uploaded_file = with_selected_action_id(action.id) { attachment.file }
+  assign_attachment uploaded_file, action.comment
+end
+
+def assign_attachment file, original_filename
+  send "#{attachment_name}=", file
+  write_identifier
+  @current_action&.update! comment: original_filename
+end
+
+event :delete_cached_upload_file_on_create, :integrate,
+      on: :create, when: :save_preliminary_upload? do
+  return unless (action = Card::Action.fetch(@action_id_of_cached_upload))
+  upload_cache_card.delete_files_for_action action
+  action.delete
+end
+
+# at some point uploaded files of canceled file card creation
+# should be deleted. We do this when ever an new file is created.
+event :clear_draft_files, :integrate_with_delay, priority: 100, on: :create do
+  Card.delete_tmp_files_of_cached_uploads
+end
+
+event :delete_cached_upload_file_on_update, :integrate,
+      on: :update, when: :save_preliminary_upload? do
+  return unless  (action = Card::Action.fetch(@action_id_of_cached_upload))
+  delete_files_for_action action
+  action.delete
+end
+
+# used for uploads for new cards until the new card is created
+def upload_cache_card
+  cache_card_codename = "new_#{attachment_name}"
+  @upload_cache_card ||= Card::Codename.card(cache_card_codename) { Card[:new_file] }
+end
+
+def preliminary_upload?
+  Card::Env && Card::Env.params[:attachment_upload]
+end
+
+def save_preliminary_upload?
+  @action_id_of_cached_upload.present?
+end
+
+# place for files if card doesn't have an id yet
+def tmp_upload_dir _action_id=nil
+  "#{files_base_dir}/#{upload_cache_card.id}"
+end

data/set/abstract/attachment/web.rb

@@ -0,0 +1,3 @@
+def no_upload?
+  web? || storage_type_from_config == :web
+end

data/set/all/file_utils.rb

@@ -0,0 +1,41 @@
+module ClassMethods
+  def update_all_storage_locations
+    Card.search(type_id: ["in", Card::FileID, Card::ImageID])
+        .each(&:update_storage_location!)
+  end
+
+  def delete_tmp_files_of_cached_uploads
+    cards_with_disposable_attachments do |card, action|
+      card.delete_files_for_action action
+      action.delete
+    end
+  end
+
+  def cards_with_disposable_attachments
+    draft_actions_with_attachment.each do |action|
+      # we don't want to delete uploads in progress
+      next unless old_enough?(action.created_at) && (card = action.card)
+      # we can't delete attachments we don't have write access to
+      next if card.read_only?
+
+      yield card, action
+    end
+  end
+
+  def old_enough? time, expiration_time=5.day.to_i
+    Time.now - time > expiration_time
+  end
+
+  def draft_actions_with_attachment
+    Card::Action.find_by_sql(
+      "SELECT * FROM card_actions "\
+        "INNER JOIN cards ON card_actions.card_id = cards.id "\
+        "WHERE cards.type_id IN (#{Card::FileID}, #{Card::ImageID}) "\
+        "AND card_actions.draft = true"
+    )
+  end
+
+  def count_cards_with_attachment
+    Card.search type_id: ["in", Card::FileID, Card::ImageID], return: :count
+  end
+end

data/set/self/admin.rb

@@ -0,0 +1,23 @@
+add_to_basket(
+  :tasks,
+  name: :update_file_storage_locations,
+  execute_policy: -> { Card.update_all_storage_locations },
+  stats: {
+    title: "cards with attachment",
+    count: -> { Card.count_cards_with_attachment }
+    # link_text: "update storage locations",
+    # task: "update_file_storage_locations"
+  }
+)
+
+add_to_basket(
+  :tasks,
+  name: :delete_upload_tmp_files,
+  execute_policy: -> { Card.delete_tmp_files_of_cached_uploads },
+  stats: {
+    title: "tmp files of canceled uploads",
+    count: -> { ::Card.draft_actions_with_attachment },
+    link_text: "delete tmp files",
+    task: "delete_tmp_files_of_cached_uploads"
+  }
+)

data/set/self/favicon.rb

@@ -0,0 +1,16 @@
+format :html do
+  view :source do
+    source = card.type_id == Card::ImageID ? super() : nil
+    source.present? ? source : nest(:logo, view: :source, size: voo.size)
+  end
+
+  view :link_tag, perms: :none do
+    return unless (source = render :source, size: :small)
+    tag :link, rel: "shortcut icon", href: source
+  end
+
+  def raw_help_text
+    "A favicon (or shortcut icon) is a small image used by browsers to help identify "\
+    "your website. [[http://www.decko.org/favicon|How to customize your favicon]]"
+  end
+end

data/set/self/new_file.rb

@@ -0,0 +1,13 @@
+format :html do
+  view :source, cache: :never do
+    super()
+  end
+
+  view :core, cache: :never do
+    super()
+  end
+
+  view :input, cache: :never do
+    super()
+  end
+end

data/set/self/new_image.rb

@@ -0,0 +1,13 @@
+format :html do
+  view :source, cache: :never do
+    super()
+  end
+
+  view :core, cache: :never do
+    super()
+  end
+
+  view :input, cache: :never do
+    super()
+  end
+end

data/set/type/file.rb

@@ -0,0 +1,116 @@
+attachment :file, uploader: CarrierWave::FileCardUploader
+
+module SelectedAction
+  def select_action_by_params params
+    # skip action table lookups for current revision
+    rev_id = params[:rev_id]
+    super unless rev_id && rev_id == last_content_action_id
+  end
+
+  def last_content_action_id
+    return super if temporary_storage_type_change?
+    # find action id from content (saves lookups)
+    db_content.to_s.split(%r{[/\.]})[-2]
+  end
+end
+include SelectedAction
+
+format do
+  view :source do
+    file = card.attachment
+    return "" unless file.valid?
+    contextualize_path file.url
+  end
+
+  view :core do
+    handle_source do |source|
+      card_url source
+    end
+  end
+
+  def short_content
+    number_to_human_size card.attachment.size
+  end
+
+  def handle_source
+    source = _render_source
+    return "" if source.blank?
+    block_given? ? yield(source) : source
+  rescue => e
+    Rails.logger.info "Error with file source: #{e.message}"
+    tr :file_error
+  end
+
+  def selected_version
+    card.attachment
+  end
+end
+
+format :file do
+  # NOCACHE because returns send_file args.  not in love with this...
+  view :core, cache: :never do
+    # this means we only support known formats.  dislike.
+    attachment_format = card.attachment_format(params[:format])
+    return _render_not_found unless attachment_format
+    return card.format(:html).render_core if card.remote_storage?
+    set_response_headers
+    args_for_send_file
+  end
+
+  def args_for_send_file
+    file = selected_version
+    [file.path, { type: file.content_type,
+                  filename:  "#{card.name.safe_key}#{file.extension}",
+                  x_sendfile: true,
+                  disposition: (params[:format] == "file" ? "attachment" : "inline") }]
+  end
+
+  def set_response_headers
+    return unless params[:explicit_file] && (response = controller&.response)
+    response.headers["Expires"] = 1.year.from_now.httpdate
+    # currently using default "private", because proxy servers could block
+    # needed permission checks
+    # r.headers["Cache-Control"] = "public"
+  end
+end
+
+format :html do
+  view :core do
+    handle_source do |source|
+      "<a href=\"#{source}\">#{tr :download, title: title_in_context(voo.title)}</a>"
+    end
+  end
+
+  view :input do
+    if card.no_upload?
+      text_field :content, class: "d0-card-content"
+    else
+      haml :file_chooser, action_text: file_chooser_action_text
+    end
+  end
+
+  view :preview_editor, unknown: true, cache: :never do
+    haml :preview_editor
+  end
+
+  def file_chooser_action_text
+    action = card.new_card? ? "Add" : "Replace"
+    "#{action} #{humanized_attachment_name}..."
+  end
+
+  def humanized_attachment_name
+    card.attachment_name.to_s.humanize
+  end
+
+  def preview
+    ""
+  end
+
+  def cached_upload_card_name
+    Card::Env.params[:attachment_upload].gsub(/\[\w+\]$/, "[action_id_of_cached_upload]")
+  end
+
+  def preview_editor_delete_text
+    tr :delete
+  end
+end

data/set/type/file/file_chooser.haml

@@ -0,0 +1,15 @@
+.choose-file
+  = preview
+  %span.btn.btn-secondary.fileinput-button
+    = icon_tag "cloud_upload"
+    %span<
+      = action_text
+    %input.file-upload.slotter.form-control{ id: "card_#{card.type_code}",
+                                             name: "card[#{card.type_code}]",
+                                             type: "file" }
+    = hidden_field_tag "attachment_type_id", card.type_id
+    = hidden_field card.attachment_name, class: "attachment_card_name", value: ""
+    = hidden_field_tag 'file_card_name', card.name.url_key
+#progress.progress.mb-2{ style: "display: none;" }
+  .progress-bar.progress-bar-success{ style: "width: 0%;" }
+.chosen-file

data/set/type/file/preview_editor.haml

@@ -0,0 +1,19 @@
+.chosen-file
+  %input{ name: cached_upload_card_name, type: "hidden", value: card.selected_action_id }
+  %table.table.table-striped{ role: "presentation" }
+    %tbody.files
+      %tr.template-download.fade.show
+        %td
+          %span.preview
+            = preview
+        %td
+          %p.name
+            = card.original_filename
+        %td
+          %span.size
+            = number_to_human_size card.attachment.size
+        %td.float-right
+          %button.btn.btn-danger.delete.cancel-upload{ "data-type": "DELETE" }
+            = icon_tag :delete
+            %span
+              = preview_editor_delete_text

data/set/type/image.rb

@@ -0,0 +1,101 @@
+attachment :image, uploader: CarrierWave::ImageCardUploader
+
+include File::SelectedAction
+
+def create_versions? new_file
+  new_file.extension != "svg"
+end
+
+def svg?
+  image&.extension == ".svg"
+end
+
+format do
+  include File::Format
+
+  view :one_line_content do
+    _render_core size: :icon
+  end
+
+  def short_content
+    render_core size: :icon
+  end
+
+  view :source do
+    return card.content if card.web?
+    image = selected_version
+    return "" unless image.valid?
+    contextualize_path image.url
+  end
+
+  def selected_version
+    size = determine_image_size
+    if size && size != :original
+      card.image.versions[size]
+    else
+      card.image
+    end
+  end
+
+  def handle_source
+    super
+  end
+
+  def closed_size
+    :icon
+  end
+
+  def main_size
+    :large
+  end
+
+  def default_size
+    :medium
+  end
+
+  def determine_image_size
+    voo.size =
+      case
+      when nest_mode == :closed then closed_size
+      when voo.size.present?    then voo.size.to_sym
+      when main?                then main_size
+      else                           default_size
+      end
+    voo.size = :original if voo.size == :full
+    voo.size
+  end
+
+  view :inline do
+    _render_core
+  end
+end
+
+format :email_html do
+  view :inline, cache: :never do
+    handle_source do |source|
+      return source unless (mail = inherit :active_mail) &&
+                           ::File.exist?(path = selected_version.path)
+      url = attach_image mail, path
+      image_tag url
+    end
+  end
+
+  def attach_image mail, path
+    mail.attachments.inline[path] = ::File.read path
+    mail.attachments[path].url
+  end
+end
+
+format :css do
+  view :core do
+    handle_source
+  end
+
+  view :content do  # why is this necessary?
+    render_core
+  end
+end
+
+format :file do
+  include File::FileFormat
+end