effective_assets 0.1

data/app/models/effective/asset.rb

@@ -0,0 +1,224 @@
+module Effective
+  class Asset < ActiveRecord::Base
+    self.table_name = EffectiveAssets.assets_table_name.to_s
+
+    mount_uploader :data, EffectiveAssets.uploader
+
+    belongs_to :user if defined?(User)
+    # This is the user that uploaded the asset.
+    # We are using belongs_to because it makes all the permissions 'just work',
+    # in letting people create assets.
+    #
+    # But this doesn't exactly belong to a user.
+    # Assets belong to acts_as_asset_box enabled classes through attachments.
+    #
+    # 1.  The S3 uploader makes a post to s3_controller#create
+    # 2.  The asset is created by the current_user
+    # 3.  But it doesn't belong to anything yet.  It might be attached to a user's asset_boxes, or a page, or a post through attachments
+    #
+
+    has_many :attachments, :dependent => :delete_all
+
+    structure do
+      title           :string
+      description     :text
+      tags            :string
+
+      content_type    :string, :validates => [:presence]
+      upload_file     :string    # The full url of the file, as originally uploaded
+      processed       :boolean, :default => false
+
+      data            :string
+
+      data_size       :integer
+      height          :integer, :validates => [:numericality => { :allow_nil => true }]
+      width           :integer, :validates => [:numericality => { :allow_nil => true }]
+
+      versions_info   :text   # We store a hash of {:thumb => 34567, :medium => 3343434} data sizes
+
+      timestamps
+    end
+
+    serialize :versions_info, Hash
+
+    #attr_accessible :title, :description, :tags, :content_type, :data_size, :upload_file, :user, :user_id, :id
+    #validates_presence_of :user_id
+
+    before_save :update_asset_dimensions
+
+    default_scope order('created_at DESC')
+
+    scope :images, -> { where('content_type LIKE ?', '%image%') }
+    scope :videos, -> { where('content_type LIKE ?', '%video%') }
+    scope :audio, -> { where('content_type LIKE ?', '%audio%') }
+    scope :files, -> { where('(content_type NOT LIKE ?) AND (content_type NOT LIKE ?) AND (content_type NOT LIKE ?)', '%image%', '%video%', '%audio%') }
+
+    scope :today, -> { where("created_at >= ?", Date.today.beginning_of_day) }
+    scope :this_week, -> { where("created_at >= ?", Date.today.beginning_of_week) }
+    scope :this_month, -> { where("created_at >= ?", Date.today.beginning_of_month) }
+
+    class << self
+      def s3_base_path
+        "http://#{EffectiveAssets.aws_bucket}.s3.amazonaws.com"
+      end
+
+      def string_base_path
+        "string://"
+      end
+
+      # Just call me with Asset.create_from_url('http://somewhere.com/somthing.jpg')
+      def create_from_url(url, options = {})
+        opts = {:upload_file => url, :user_id => 1}.merge(options)
+
+        if (asset = Asset.create(opts))
+          Effective::DelayedJob.new.process_asset(asset)
+          asset
+        else
+          false
+        end
+      end
+
+      # We have just uploaded an asset via our s3 uploader
+      # We want this image to be immediately available.
+      def create_from_s3_uploader(url, options = {})
+        opts = {:upload_file => "#{Asset.s3_base_path}/#{url}", :user_id => 1}.merge(options)
+
+        asset = false
+
+        Asset.transaction do
+          begin
+            asset = Asset.create!(opts)
+
+            Rails.logger.info "Copying s3 uploaded file to final resting place..."
+            storage = Fog::Storage.new(:provider => 'AWS', :aws_access_key_id => EffectiveAssets.aws_access_key_id, :aws_secret_access_key => EffectiveAssets.aws_secret_access_key)
+            storage.copy_object(EffectiveAssets.aws_bucket, url, EffectiveAssets.aws_bucket, "#{EffectiveAssets.aws_final_path.chomp('/')}/#{asset.id}/#{asset.file_name}")
+            storage.put_object_acl(EffectiveAssets.aws_bucket, "#{EffectiveAssets.aws_final_path.chomp('/')}/#{asset.id}/#{asset.file_name}", EffectiveAssets.aws_acl)
+
+            Rails.logger.info "Deleting original..."
+            directory = storage.directories.get(EffectiveAssets.aws_bucket)
+            directory.files.new(:key => url).destroy
+
+            asset.update_column(:upload_file, asset.url) # This is our upload file as far as CarrierWave is now concerned
+
+            Effective::DelayedJob.new.process_asset(asset)
+          rescue => e
+            Rails.logger.info e.message
+            Rails.logger.info e.backtrace.join('\n')
+            asset = false
+          end
+
+          raise ActiveRecord::Rollback unless asset
+        end
+
+        asset
+      end
+
+      # This loads the raw contents of a string into a file and uploads that file to s3
+      # Expect to be passed something like
+      # Asset.create_from_string('some binary stuff from a string', :filename => 'icon_close.png', :content_type => 'image/png')
+      def create_from_string(str, options = {})
+        filename = options.delete(:filename) || "file-#{Time.now.strftime('%Y-%m-%d-%H-%M-%S')}.txt"
+
+        opts = {:upload_file => "#{Asset.string_base_path}#{filename}", :user_id => 1}.merge(options)
+
+        asset = Asset.new(opts)
+        asset.data = AssetStringIO.new(filename, str)
+
+        if asset.save
+          Effective::DelayedJob.new.process_asset(asset)
+          asset
+        end
+      end
+    end
+
+    before_validation do
+      if !content_type.present? or content_type == 'null' or content_type == 'unknown' or content_type == 'application/octet-stream'
+        self.content_type = case url.to_s[-4, 4].downcase
+          when '.mp3' ; 'audio/mp3'
+          when '.mp4' ; 'video/mp4'
+          when '.mov' ; 'video/mov'
+          when '.m2v' ; 'video/m2v'
+          when '.m4v' ; 'video/m4v'
+          when '.3gp' ; 'video/3gp'
+          when '.3g2' ; 'video/3g2'
+          when '.avi' ; 'video/avi'
+          when '.jpg' ; 'image/jpg'
+          when '.gif' ; 'image/gif'
+          when '.png' ; 'image/png'
+          when '.bmp' ; 'image/bmp'
+          when '.ico' ; 'image/x-icon'
+          else ; 'unknown'
+        end
+      end
+    end
+
+    def title
+      self[:title].present? ? self[:title] : file_name
+    end
+
+    # Return the final location of this asset
+    def url
+      "#{Asset.s3_base_path}/#{EffectiveAssets.aws_final_path.chomp('/')}/#{self.id.to_i}/#{upload_file.to_s.split('/').last}"
+    end
+
+    def file_name
+      url.split('/').last rescue url
+    end
+
+    def video?
+      content_type.include? 'video'
+    end
+
+    def image?
+      content_type.include? 'image'
+    end
+
+    def icon?
+      content_type.include? 'image/x-icon'
+    end
+
+    def audio?
+      content_type.include? 'audio'
+    end
+
+    def as_json(options={})
+      {:thumbnail => image_tag(:thumb).html_safe}.merge super
+    end
+
+    def still_processing?
+      !processed
+    end
+
+    def versions_info
+      self[:versions_info] || {}
+    end
+
+    protected
+     # Called in the DelayedJob
+     def update_asset_dimensions
+      if data.present? and data_changed? and image?
+        begin
+          image = MiniMagick::Image.open(self.data.path)
+          self.width = image[:width]
+          self.height = image[:height]
+        rescue => e
+        end
+      end
+      true
+    end
+  end
+
+  class AssetStringIO < StringIO
+    attr_accessor :filepath
+
+    def initialize(*args)
+      super(*args[1..-1])
+      @filepath = args[0]
+    end
+
+    def original_filename
+      File.basename(filepath)
+    end
+  end
+end
+

data/app/models/effective/attachment.rb

@@ -0,0 +1,25 @@
+# This is a join table for assets and acts_as_attachable
+
+module Effective
+  class Attachment < ActiveRecord::Base
+    self.table_name = EffectiveAssets.attachments_table_name.to_s
+
+    belongs_to :asset
+    belongs_to :attachable, :polymorphic => true
+
+    structure do
+      position        :integer, :validates => [:presence, :numericality]
+      box             :string, :default => 'assets', :validates => [:presence]  # This is essentially a category
+    end
+
+    validates_presence_of :asset_id
+
+    #attr_accessible :box, :position, :asset_id, :attachable_type, :attachable_id
+
+    class << self
+      def default_scope
+        includes(:asset).order(:position)
+      end
+    end
+  end
+end

data/app/models/effective/delayed_job.rb

@@ -0,0 +1,99 @@
+#require 'uri'
+# Call with DelayedJob.new.process_asset_images(...)
+# Run jobs locally with "rake jobs:work"
+
+module Effective
+  class DelayedJob
+    def process_asset(asset)
+      DelayedJob.configure_carrierwave
+
+      if asset and !asset.processed? and asset.upload_file.present?
+        begin
+          puts "Processing an asset ID ##{asset.id}..."
+
+          if asset.upload_file.include?("#{Asset.s3_base_path}")
+            if asset.image?
+              puts "Asset is an image in our S3 assets directory.  Downloading and processing..."
+
+              # Carrierwave must download the file, process it, then re-upload it to S3
+              asset.remote_data_url = asset.upload_file
+              asset.processed = true
+              asset.save!
+            else
+              puts "Asset is a non-image in our S3 uploads directory.  Copying to final location..."
+
+              # We have uploaded a video, or something non-image to our S3 bucket.
+              # We do not currently process anything.
+
+              puts "Marking local asset as processed..."
+              asset.update_column(:data, asset.file_name)
+              asset.processed = true
+              asset.save!
+            end
+          elsif asset.upload_file.include?(Asset.string_base_path)
+            puts "Asset is a string-based asset.  Processing..."
+
+            asset.data.cache_stored_file!
+            asset.data.retrieve_from_cache!(asset.data.cache_name)
+            asset.data.recreate_versions!
+            asset.processed = true
+            asset.save!
+          else
+            puts "Asset is not an s3 uploaded asset.  Downloading and processing..."
+
+            # Carrierwave must download the file, process it, then re-upload it to S3
+            asset.remote_data_url = asset.upload_file
+            asset.processed = true
+            asset.save!
+          end
+
+          puts "Successfully processed the asset."
+        rescue => e
+          puts "An error occurred while processing an asset:"
+          puts e.message
+          puts e.backtrace.inspect
+        end
+      end
+    end
+    handle_asynchronously :process_asset
+
+    def reprocess_all_assets
+      DelayedJob.configure_carrierwave
+
+      Asset.all.each do |asset|
+        begin
+          puts "Processing Asset ID=#{asset.id}..."
+          asset.data.cache_stored_file!
+          asset.data.retrieve_from_cache!(asset.data.cache_name)
+          asset.data.recreate_versions!
+          asset.save!
+          puts "Successfully processed #{asset.inspect}"
+        rescue => e
+          puts  "ERROR: #{asset.id} -> #{e.to_s}"
+        end
+      end
+    end
+    handle_asynchronously :reprocess_all_assets
+
+    def self.configure_carrierwave
+      return if defined? @@configured_carrierwave
+
+      CarrierWave.configure do |config|
+        config.fog_credentials = {
+          :provider               => 'AWS',
+          :aws_access_key_id      => EffectiveAssets.aws_access_key_id,
+          :aws_secret_access_key  => EffectiveAssets.aws_secret_access_key
+        }
+        config.fog_directory  = EffectiveAssets.aws_bucket
+        config.fog_public     = EffectiveAssets.aws_acl.to_s.include?('public')
+        config.fog_attributes = {'Cache-Control'=>'max-age=315576000'}
+        config.cache_dir      = "#{Rails.root}/tmp/uploads" # For heroku
+      end
+
+      Rails.logger.info "CONFIGURED CARRIERWAVE"
+
+      @@configured_carrierwave = true
+    end
+
+  end
+end

data/app/models/inputs/asset_box_input.rb

@@ -0,0 +1,87 @@
+require "formtastic"
+
+# With formtastic, just use
+#
+# = f.input :pictures, :as => :asset_box
+# = f.input :fav_icon, :as => :asset_box, :limit => 4, :file_types => [:jpg, :gif, :png]
+# = f.input :logo, :as => :asset_box, :uploader => false, :dialog => true
+# = f.input :logo, :as => :asset_box, :uploader => true, :uploader_visible => true
+
+class AssetBoxInput
+  include ::Formtastic::Inputs::Base
+
+  def to_html
+    @@uid = (@@uid ||= 0) + 1 # We just need a unique number to pass along, incase we have multiple SWF Uploaders per form
+
+    input_wrapping do
+      output = label_html
+      output += header_html
+      output += "<div class='attachments'>".html_safe
+      output += build_values_html
+      output += "</div>".html_safe
+
+      if options[:uploader]
+        output += insert_uploader_html
+        output += uploader_html
+      end
+
+      if options[:dialog]
+        output += insert_dialog_html
+      end
+
+      output += "</div>".html_safe
+    end
+  end
+
+  def header_html
+    "<div class='asset_box_input #{method.to_s.pluralize}' data-box='#{method.to_s.pluralize}' data-swf='s3_swf_#{@@uid}' data-limit='#{limit}' data-attachable-id='#{attachable_id}' data-attachable-type='#{attachable_type}'>".html_safe
+  end
+
+  def insert_uploader_html
+    "<a href='#' class='asset-box-upload'>Upload...</a>".html_safe
+  end
+
+  def uploader_html
+    template.render(:partial => 'asset_box_input/uploader', :locals => {:attachable_id => attachable_id, :attachable_type => attachable_type, :box => method.to_s.pluralize, :uid => @@uid, :file_types => options[:file_types], :limit => limit, :uploader_visible => options[:uploader_visible]}).html_safe
+  end
+
+  def insert_dialog_html
+    "<a href='#' class='asset-box-dialog'>Attach...</a>".html_safe
+  end
+
+  def build_values_html
+    count = 0
+    attachments_limit = limit
+
+    attachments.map do |attachment|
+      count += 1 unless attachment.marked_for_destruction?
+
+      template.render(
+        :partial => 'asset_box_input/attachment_fields',
+        :locals => {:attachment => attachment, :attachable_type => attachable_type, :hidden => (count > attachments_limit) }
+      )
+    end.join.html_safe
+  end
+
+  def attachments
+    method_name = method.to_s.pluralize
+    object.attachments.select { |attachment| attachment.box == method_name }
+  end
+
+  def attachable_type
+    options[:attachable_type] || object.class.name.titleize.gsub(" ", "_").gsub('/', '_').downcase
+  end
+
+  def attachable_id
+    options[:attachable_id] || (object.try(:id) rescue nil)
+  end
+
+  def limit
+    method.to_s == method.to_s.pluralize ? (options[:limit] || 10000) : 1
+  end
+
+  def options
+    {:uploader => false, :dialog => false, :uploader_visible => false}.merge(super)
+  end
+
+end

data/app/models/validators/asset_box_length_validator.rb

@@ -0,0 +1,11 @@
+class AssetBoxLengthValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    num_in_box = (record.attachments || []).select { |attachment| attachment.box == attribute.to_s.pluralize && attachment.marked_for_destruction? == false }.size
+
+    if options[:with]
+      record.errors[attribute] << "requires at least #{options[:with]} #{attribute.to_s.pluralize}" if num_in_box < options[:with]
+    elsif options[:in]
+      record.errors[attribute] << "requires #{options[:in].min} to #{options[:in].max} #{attribute.to_s.pluralize}" if options[:in].include?(num_in_box) == false
+    end
+  end
+end