image_uploader.rb

require 'uuidtools'

class ImageUploader < CarrierWave::Uploader::Base
  include CarrierWave::Vips
  #include CarrierWave::RMagick
  include ::CarrierWave::Backgrounder::Delay
  #include ModuleHelper::Helper
  # Include the Sprockets helpers for Rails 3.1+ asset pipeline compatibility:
  include Sprockets::Helpers::RailsHelper
  include Sprockets::Helpers::IsolatedHelper
  
  include CarrierWave::MimeTypes
  include NumberHelper
  process :set_content_type
  # Choose what kind of storage to use for this uploader:
  storage :file
  after :store, :update_model_fs_path
  
  def default_url
    asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
  end
  def processing_url
    asset_path("processing_throbber2.gif")
  end
  #usually the update_fs_path is called in the after_save of filesystemable, 
  #but with carrierwave files, the file isn't stored until after the after_save
  #callbacks of activerecord. Hence this after :store method
  def update_model_fs_path(file)
    model.update_fs_path
  end
    
  def move_to_store
    true
  end
  
  #Note, adding this causes versions to fail (don't do it)
  # def move_to_cache
  #   true
  # end

  # Override the directory where uploaded files will be stored.
  # This is a sensible default for uploaders that are meant to be mounted:
  def store_dir
    return model.filesystem_dir
  end
  
  def url 
    if model.image.present? && File.exists?(self.file.path)
      super
    elsif model.image_tmp.present?
      self.processing_url
    else
      self.default_url
    end
  end

  # Create different versions of your uploaded files:
  version :medium, if: :not_format_3FR? do 
    def store_dir
      if Rails.env.test?
        "uploads/test/versions"
      else
        "uploads/versions"
      end
    end
    def full_filename (for_file = model.image.file)
      "medium_#{secure_token}.jpeg" 
    end
    def url 
      if model.image.present? && File.exists?(self.file.path)
        super
      elsif model.image_tmp.present?
        self.processing_url
      else
        self.default_url
      end
    end
    process :convert_to_8bit
    process :convert => :jpeg
    process :resize_to_limit => [450,450]
    process quality: 75
  end 
  version :small, from_version: :medium, if: :not_format_3FR? do 
    def store_dir
      if Rails.env.test?
        "uploads/test/versions"
      else
        "uploads/versions"
      end
    end
    def full_filename (for_file = model.image.file)
      "small_#{secure_token}.jpeg"
    end
    def url 
      if model.image.present? && File.exists?(self.file.path)
        super
      elsif model.image_tmp.present?
        self.processing_url
      else
        self.default_url
      end
    end
    process :convert_to_8bit
    process :convert => :jpeg
    process :resize_to_limit => [200,200]
  end 
  version :thumb, from_version: :small, if: :not_format_3FR? do 
    def store_dir
      if Rails.env.test?
        "uploads/test/versions"
      else
        "uploads/versions"
      end
    end
    def full_filename (for_file = model.image.file)
      "thumb_#{secure_token}.jpeg" 
    end
    def url 
      if model.image.present? && File.exists?(self.file.path)
        super
      elsif model.image_tmp.present?
        self.processing_url
      else
        self.default_url
      end
    end
    process :convert_to_8bit
    process :convert => :jpeg
    process :resize_to_limit => [75,75]
  end 

  def convert_to_8bit
    manipulate! do |image|
      #vips specific
      image.scale
    end
  end

  # Add a white list of extensions which are allowed to be uploaded.
  # For images you might use something like this:
  # def extension_white_list
  #   %w(jpg jpeg gif png)
  # end

  # Override the filename of the uploaded files:
  # Avoid using model.id or version_name here, see uploader/store.rb for details.
  def filename
    #when recreating versions, the image is restored, which causes this method to be called on the
    #previously renamed image (the one that already has the secure token). This just checks to see
    #if the secure_token is already there, and if it is, skips the file name adjustments step.
    if file.filename=~/#{secure_token}/
      super
    elsif  original_filename.present?
      "#{file.basename}_#{secure_token}.#{file.extension}" 
    end
  end
  
  protected
  
  def not_format_3FR?(new_file)
    match = new_file.filename=~/\.3FR$/
    match.nil?
  end
  
  def secure_token
    model.image_secure_token ||= UUIDTools::UUID.timestamp_create().to_s
  end
  


end