card 1.19.0 → 1.19.1

data/mod/carrierwave/set/abstract/attachment/paths.rb

@@ -0,0 +1,50 @@
+MOD_FILE_DIR = "file".freeze
+
+def store_dir
+  will_become_coded? ? coded_dir(@new_mod) : upload_dir
+end
+
+def retrieve_dir
+  coded? ? coded_dir : upload_dir
+end
+
+# place for files of regular file cards
+def upload_dir
+  id ? "#{files_base_dir}/#{id}" : tmp_upload_dir
+end
+
+# place for files of mod file cards
+def coded_dir new_mod=nil
+  dir = File.join mod_dir(new_mod), MOD_FILE_DIR, codename
+  FileUtils.mkdir_p dir
+  dir
+end
+
+def mod_dir new_mod=nil
+  find_mod = new_mod || mod
+  Card::Mod::Loader.mod_dirs.path(find_mod) ||
+    raise(Error, "can't find mod \"#{find_mod}\"")
+end
+
+def files_base_dir
+  bucket ? bucket_config[:subdirectory] : Card.paths["files"].existent.first
+end
+
+# used in the indentifier
+def file_dir
+  if coded?
+    ":#{codename}"
+  elsif cloud?
+    "(#{bucket})/#{file_id}"
+  else
+    "~#{file_id}"
+  end
+end
+
+def public?
+  who_can(:read).include? Card[:anyone].id
+end
+
+def file_id
+  id? ? id : upload_cache_card.id
+end

data/mod/carrierwave/set/abstract/attachment/storage_type.rb

@@ -0,0 +1,319 @@
+attr_writer :bucket, :storage_type
+
+event :storage_type_change, :store,
+      on: :update, when: proc { |c| c.storage_type_changed? } do
+  # carrierwave stores file if @cache_id is not nil
+  attachment.cache_stored_file!
+  # attachment.retrieve_from_cache!(attachment.cache_name)
+  update_storage_attributes
+  # next line might be necessary to move files to cloud
+
+  # make sure that we get the new identifier
+  # otherwise action_id will return wrong id for new identifier
+  db_content_will_change!
+  write_identifier
+end
+
+event :validate_storage_type, :validate,
+      on: :save do
+  if will_become_coded?
+    unless mod || @new_mod
+      errors.add :storage_type, "mod argument needed to save card as coded"
+    end
+    if codename.blank?
+      errors.add :storage_type, "codename needed for storage type coded"
+    end
+  end
+  unless known_storage_type? will_be_stored_as
+    errors.add :storage_type, "unknown storage type: #{@new_storage_type}"
+  end
+end
+
+event :validate_storage_type_update, :validate,
+      on: :update do
+  if cloud? && storage_type_changed?
+    errors.add :storage_type, "moving files from cloud elsewhere "\
+                              "is not supported"
+  end
+end
+
+event :loose_coded_status_on_update, :initialize,
+      on: :update, when: proc { |c| c.coded? } do
+  return if @new_mod
+  @new_storage_type ||= storage_type_from_config
+end
+
+event :update_public_link_on_create, :integrate,
+      on: :create,
+      when: proc { |c| c.local? } do
+  update_public_link
+end
+
+event :remove_public_link_on_delete, :integrate,
+      on: :delete,
+      when: proc { |c| c.local? } do
+  remove_public_links
+end
+
+event :update_public_link, after: :update_read_rule,
+                           when: proc { |c| c.local? } do
+  return if content.blank?
+  if who_can(:read).include? Card[:anyone].id
+    create_public_links
+  else
+    remove_public_links
+  end
+end
+
+def create_public_links
+  path = attachment.public_path
+  return if File.exist? path
+  FileUtils.mkdir_p File.dirname(path)
+  File.symlink attachment.path, path unless File.symlink? path
+  create_versions_public_links
+end
+
+def create_versions_public_links
+  attachment.versions.each do |_name, version|
+    next if File.symlink? version.public_path
+    File.symlink version.path, version.public_path
+  end
+end
+
+def remove_public_links
+  symlink_dir = File.dirname attachment.public_path
+  return unless Dir.exist? symlink_dir
+  FileUtils.rm_rf symlink_dir
+end
+
+def will_be_stored_as
+  @new_storage_type || storage_type
+end
+
+def cloud?
+  storage_type == :cloud
+end
+
+def web?
+  storage_type == :web
+end
+
+def local?
+  storage_type == :local
+end
+
+def coded?
+  storage_type == :coded
+end
+
+def will_become_coded?
+  will_be_stored_as == :coded
+end
+
+def deprecated_mod_file?
+  content && (lines = content.split("\n")) && lines.size == 4
+end
+
+def mod
+  @mod ||= coded? && mod_from_content
+end
+
+def mod_from_content
+  if content =~ %r{^:[^/]+/([^.]+)}
+    Regexp.last_match(1) # current mod_file format
+  else
+    mod_from_deprecated_content
+  end
+end
+
+# old format is still used in card_changes
+def mod_from_deprecated_content
+  return if content =~ /^\~/
+  return unless (lines = content.split("\n")) && lines.size == 4
+  lines.last
+end
+
+def remote_storage?
+  cloud? || web?
+end
+
+def no_upload?
+  storage_type_from_config == :web
+end
+
+def bucket
+  @bucket ||= cloud? &&
+              ((new_card? && bucket_from_config) || bucket_from_content ||
+                bucket_from_config)
+end
+
+def bucket_config
+  @bucket_config ||= load_bucket_config
+end
+
+def load_bucket_config
+  return {} unless bucket
+  bucket_config = Cardio.config.file_buckets &&
+                  Cardio.config.file_buckets[bucket.to_sym]
+  bucket_config &&= bucket_config.symbolize_keys
+  bucket_config ||= {}
+  # we don't want :attributes hash symbolized, so we can't use
+  # deep_symbolize_keys
+  bucket_config[:credentials] &&= bucket_config[:credentials].symbolize_keys
+  ensure_bucket_config do
+    load_bucket_config_from_env bucket_config
+  end
+end
+
+def ensure_bucket_config
+  config = yield
+  unless config.present?
+    raise Card::Error, "couldn't find configuration for bucket #{bucket}"
+  end
+  config
+end
+
+def load_bucket_config_from_env config
+  config ||= {}
+  CarrierWave::FileCardUploader::CONFIG_OPTIONS.each do |key|
+    next if key.in? [:attributes, :credentials]
+    replace_with_env_variable config, key
+  end
+  config[:credentials] ||= {}
+  load_bucket_credentials_from_env config[:credentials]
+  config.delete :credentials unless config[:credentials].present?
+  config
+end
+
+def load_bucket_credentials_from_env cred_config
+  cred_opt_pattern =
+    Regexp.new(/^(?:#{bucket.to_s.upcase}_)?CREDENTIALS_(?<option>.+)$/)
+  ENV.keys.each do |env_key|
+    next unless (m = cred_opt_pattern.match(env_key))
+    replace_with_env_variable cred_config, m[:option].downcase.to_sym,
+                              "credentials"
+  end
+end
+
+def replace_with_env_variable config, option, prefix=nil
+  env_key = [prefix, option].compact.join("_").upcase
+  new_value = ENV["#{bucket.to_s.upcase}_#{env_key}"] ||
+              ENV[env_key]
+  config[option] = new_value if new_value
+end
+
+def bucket_from_content
+  return unless content
+  content.match(/^\((?<bucket>[^)]+)\)/) { |m| m[:bucket] }
+end
+
+def bucket_from_config
+  Cardio.config.file_default_bucket ||
+    (Cardio.config.file_buckets && Cardio.config.file_buckets.keys.first)
+end
+
+def storage_type
+  @storage_type ||=
+    new_card? ? storage_type_from_config : storage_type_from_content
+end
+
+def storage_type_from_config
+  type = ENV["FILE_STORAGE"] || Cardio.config.file_storage
+  return unless type
+  type = type.to_sym
+  unless type.in? CarrierWave::FileCardUploader::STORAGE_TYPES
+    raise Card::Error,
+          I18n.t(:error_invalid_storage_type,
+                 scope: "mod.carrierwave.set.abstract.attachment",
+                 type: type)
+  end
+  type
+end
+
+def storage_type_from_content
+  case content
+  when /^\(/           then :cloud
+  when %r{/^https?\:/} then :web
+  when /^~/            then :local
+  when /^\:/           then :coded
+  else
+    if deprecated_mod_file?
+      :coded
+    else
+      storage_type_from_config
+    end
+  end
+end
+
+def update_storage_attributes
+  @mod = @new_mod if @new_mod
+  @bucket = @new_bucket if @new_bucket
+  @storage_type = @new_storage_type
+end
+
+def storage_type_changed?
+  @new_bucket || @new_storage_type || @new_mod
+end
+
+def bucket= value
+  if @action == :update
+    @new_bucket = value
+  else
+    @bucket = value
+  end
+end
+
+def storage_type= value
+  known_storage_type? value
+  if @action == :update
+    # we cant update the storage type directly here
+    # if we do then the uploader doesn't find the file we want to update
+    @new_storage_type = value
+  else
+    @storage_type = value
+  end
+end
+
+def mod= value
+  if @action == :update
+    @new_mod = value.to_s
+  else
+    @mod = value.to_s
+  end
+end
+
+def with_storage_options opts={}
+  old_values = {}
+  validate_temporary_storage_type_change opts[:storage_type]
+  [:storage_type, :mod, :bucket].each do |opt_name|
+    next unless opts[opt_name]
+    old_values[opt_name] = instance_variable_get "@#{opt_name}"
+    instance_variable_set "@#{opt_name}", opts[opt_name]
+    @temp_storage_type = true
+  end
+  yield
+ensure
+  @temp_storage_type = false
+  old_values.each do |key, val|
+    instance_variable_set "@#{key}", val
+  end
+end
+
+def temporary_storage_type_change?
+  @temp_storage_type
+end
+
+def validate_temporary_storage_type_change new_storage_type=nil
+  new_storage_type ||= @new_storage_type
+  return unless new_storage_type
+  unless known_storage_type? new_storage_type
+    raise Error, "unknown storage type: #{new_storage_type}"
+  end
+  if new_storage_type == :coded && codename.blank?
+    raise Error, "codename needed for storage type :coded"
+  end
+end
+
+def known_storage_type? type=storage_type
+  type.in? CarrierWave::FileCardUploader::STORAGE_TYPES
+end

data/mod/carrierwave/set/abstract/attachment/upload_cache.rb

@@ -0,0 +1,77 @@
+# action id of the cached upload
+attr_accessor :action_id_of_cached_upload
+
+event :upload_attachment, :prepare_to_validate,
+      on: :save, when: proc { |c| c.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!
+  finalize_action         # create Card::Change entry for db_content
+
+  card_id = new_card? ? upload_cache_card.id : id
+  @current_action.update_attributes! 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: proc { |c| c.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:  proc { |c| c.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_attributes! comment: original_filename
+end
+
+event :delete_cached_upload_file_on_create, :integrate,
+      on: :create, when: proc { |c| c.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
+  Card.delete_tmp_files_of_cached_uploads
+end
+
+event :delete_cached_upload_file_on_update, :integrate,
+      on: :update, when: proc { |c| c.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
+  @upload_cache_card ||= Card["new_#{attachment_name}".to_sym]
+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/mod/carrierwave/set/all/file_utils.rb

@@ -0,0 +1,28 @@
+module ClassMethods
+  def update_all_storage_locations
+    Card.search(type_id: ["in", FileID, ImageID])
+        .each(&:update_storage_location!)
+  end
+
+  def delete_tmp_files_of_cached_uploads
+    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)
+      card.delete_files_for_action action
+      action.delete
+    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
+end