ruby-on-rails-3 - rails - remove image carrierwave

Vuelva a crear versiones con Carrierwave con Ruby

Question

El sitio web en el que estoy trabajando está pasando por un rediseño y, como tal, nuestras imágenes de usuario deben ser redimensionadas. El sitio web utiliza actualmente la gema carrierwave para manejar todo el procesamiento de imágenes y video, y cada imagen tiene un archivo original con un nombre de archivo único basado en lo siguiente:

def filename
  if original_filename
    if model && model.read_attribute(:user_image).present?
      model.read_attribute(:user_image)
    else
      @name ||= "#{secure_token}.#{file.extension}" if original_filename.present?
    end
  end
end

y secure_token ser generado por

def secure_token
  var = :"@#{mounted_as}_secure_token"
  model.instance_variable_get(var) or model.instance_variable_set(var, SecureRandom.uuid)
end

La tarea que se crea para hacer esto es:

##
# CarrierWave Amazon S3 File Reprocessor Rake Task
#
# Written (specifically) for:
# - CarrierWave
# - Ruby on Rails 3
# - Amazon S3
#
# Works with:
# - Any server of which you have write-permissions in the Rails.root/tmp directory
# - Works with Heroku
#
# Not tested with, but might work with:
# - Ruby on Rails 2 
#
# Might work with, after a couple of tweaks:
# - File System Storage
# - Cloud Files Storage
# - GridFS
#
# Examples:
#
# Reprocess all versions of User#avatar
#  rake carrierwave:reprocess class=User mounted_uploader=avatar
#
# Reprocess the versions: thumb, small, medium for User#avatar
#  rake carrierwave:reprocess class=User mounted_uploader=avatar versions=''thumb, small, medium''
#
# Reprocess for an underlying association, for things like Embedded MongoDB Documents
# which are models you cannot access directly, but rather through a regular Document
#
# Embeds One (picture) Association
#  rake carrierwave:reprocess class=User association=picture mounted_uploader=image versions=''thumb, small, medium''
#
# Embeds Many (pictures) Association
#  rake carrierwave:reprocess class=User association=pictures mounted_uploader=image versions=''thumb, small, medium''
#
# WARNING
# There is an issue with "Rake", that you cannot name your mounted_uploader "file".
# If you do this, then you will not be able to reprocess images through this rake task
#  class User
#    include Mongoid::Document
#    mount_uploader :file, PictureUploader
#  end
#
# This will NOT work with reprocessing through Rake because the mounted_uploader uses the "file" attribute.

namespace :carrierwave do

  ##
  # Only tested with Amazon S3 Storage
  # Needs some minor modifications if you want to use this for File System Store, Cloud Files and GridFS probably.
  # This should work without Ruby on Rails as well, just set a different TMP_PATH.
  desc "Reprocesses Carrier Wave file versions of a given model."
  task :reprocess => :environment do

    ##
    # Load in the OPEN URI library to be able
    # to pull down and store the original file in a temp directory
    require ''open-uri''

    ##
    # Default constants
    TMP_PATH          = "#{Rails.root}/tmp/carrierwave"

    ##
    # Set environment constants
    CLASS             = ENV[''class''].capitalize
    ASSOCIATION       = ENV[''association''] || nil
    MOUNTED_UPLOADER  = ENV[''mounted_uploader''].to_sym
    VERSIONS          = ENV[''versions''].nil? ? Array.new : ENV[''versions''].split('','').map {|version| version.strip.to_sym}

    ##
    # Find the Model
    MODEL = Kernel.const_get(CLASS)

    ##
    # Create the temp directory
    %x(mkdir -p "#{TMP_PATH}")

    ##
    # Find all records for the provided Model
    records = MODEL.all

    ##
    # Output to console
    puts "/nCarrier Wave Version Reprocessing!"
    puts "======================================="
    puts "Model:              #{CLASS}"
    puts "Mounted Uploader:   #{MOUNTED_UPLOADER}"
    puts "Association:        #{ASSOCIATION}" if ASSOCIATION
    puts "Versions:           #{VERSIONS.empty? ? "all" : VERSIONS.join('', '')}/n/n"

    ##
    # Run through all records
    records.each do |record|

      ##
      # Set the mounted uploader object
      # If it has a one-to-one association (singular) then that object
      # will be returned and wrapped in an array so we can "iterate" through it below.
      # 
      # If it has a one-to-many association then it will return the array of associated objects
      #
      # If no association is specified, it assumes the amounted uploader is attached to the specified CLASS 
      if ASSOCIATION
        if ASSOCIATION.singular?
          objects = [record.send(ASSOCIATION)]
        else
          objects = record.send(ASSOCIATION)        
        end
      else
        objects = [record]
      end

      ##
      # Iterates through the objects
      objects.each do |object|

        ##
        # Returns the mounted uploader object
        mounted_object = object.send(MOUNTED_UPLOADER)

        ##
        # Retrieve Filename
        filename = mounted_object.path.split(''/'').last

        ##
        # Output to console
        puts "Reprocessing: #{filename}"

        ##
        # Read out the original file from the remote location
        # and write it out to the temp directory (TMP_PATH)
        # This file will be used as the base file to reprocess
        # the versions. Once all versions have been processed,
        # this temp file will be directly removed.
        open(mounted_object.url) do |original_object|
          File.open(File.join(TMP_PATH, filename), ''w'') do |temp_file|
            temp_file.write(original_object.read)
          end
        end

        ##
        # By default it will add all available versions to the versions variable
        # which means that all available versions will be reprocessed.
        # If the "versions" argument has been provided, then only the specified
        # version(s) will be set to the versions variable, and thus, only these
        # will be reprocessed.
        versions = mounted_object.versions.map {|version| version[0]}
        versions = VERSIONS unless VERSIONS.empty?

        ##
        # Reprocesses the versions
        versions.each do |version|
          mounted_object.send(version).cache!(File.open(File.join(TMP_PATH, filename)))
          mounted_object.send(version).store!
        end

        ##
        # Removes the temp file
        %x(rm "#{TMP_PATH}/#{filename}")
      end
    end
  end
end

El problema es que, mientras crea las nuevas imágenes, los archivos se guardan con un nuevo nombre de archivo en lugar de seguir los nombres establecidos en el cargador de imágenes, por lo que el sitio web no puede encontrarlos. El siguiente es un ejemplo de cómo se almacenan las imágenes.

Como debería ser:

Archivo original: fdk392ks93_39ei.png

versión en miniatura: thumb_fdk392ks93_39ei.png

Como es:

Archivo original: fdk392ks93_39ei.png

versión en miniatura: thumb_fajeilkadifej_jakdjfi.png

Cualquier ayuda será muy apreciada.

Otra información:

Modelo: Usuario

Uploader: user_image (este es también el nombre de la columna que almacena la carpeta / nombre del archivo)

Answer 1

El archivo README establece claramente cómo recrear las versiones de Carrierwave:

https://github.com/jnicklas/carrierwave/blob/master/README.md

"Puede llegar a una situación en la que desee cambiar de forma retroactiva una versión o agregar una nueva. Puede utilizar el método recreate_versions! Para recrear las versiones desde el archivo base. Esto utiliza un enfoque ingenuo que volverá a cargar y procesar el versión especificada o todas las versiones, si no se pasa como un argumento.

instance = MyUploader.new
instance.recreate_versions!(:thumb, :large)

O en un cargador montado:

User.all.each do |user|
  user.avatar.recreate_versions!
end

Answer 2

Después de llamar a recreate_versions! tienes que llamar save! en el modelo. Puedes ver esta pregunta donde alguien preguntó básicamente lo mismo.