effective_assets 0.1 → 1.0.0

data/app/assets/stylesheets/effective_assets_iframe.css.scss

@@ -0,0 +1,23 @@
+@import "effective_assets/asset_box_input";
+
+body {
+  padding: 10px;
+}
+
+.form-control.filter-attachments {
+  display: inline;
+  font-weight: normal;
+  width: auto;
+  min-width: 50%;
+  margin-left: 10px;
+}
+
+.asset-box-input.dragin {
+  border: 1px solid blue;
+  border-radius: 4px;
+  border-color: #66afe9;
+  box-shadow: 0 1px 1px rgba(0, 0, 0, 0.075) inset, 0 0 8px rgba(102, 175, 233, 0.6);
+  outline: 0 none;
+}
+
+@import "effective_assets/iframe_bootstrap";

data/app/controllers/effective/assets_controller.rb

@@ -0,0 +1,41 @@
+# This is basically for the CkEditor Pictures functionality
+
+module Effective
+  class AssetsController < ApplicationController
+    layout false
+
+    def index  # This is the Modal dialog that is read by CKEDITOR
+      EffectiveAssets.authorized?(self, :index, Effective::Asset.new(:user_id => current_user.try(:id)))
+
+      @assets =  Effective::Asset.where(:user_id => current_user.try(:id))
+      @aws_acl = EffectiveAssets.aws_acl.presence || 'public-read'
+
+      if params[:only] == 'images'
+        @assets = @assets.images
+        @file_types = [:jpg, :gif, :png, :bmp, :ico]
+        @aws_acl = 'public-read' # The CKEditor Insert Image functionality needs a public-read image here
+      elsif params[:only] == 'nonimages'
+        @assets = @assets.nonimages
+        @file_types = [:pdf, :zip, :doc, :docx, :xls, :xlsx, :txt, :avi, :m4v, :m2v, :mov, :mp3, :mp4]
+      end
+
+      @user_uploads = UserUploads.new(@assets)
+
+      render :file => 'effective/assets/iframe'
+    end
+
+    def destroy
+      @asset = Effective::Asset.find(params[:id])
+      EffectiveAssets.authorized?(self, :destroy, @asset)
+
+      if @asset.destroy
+        flash[:success] = 'Successfully deleted asset'
+      else
+        flash[:danger] = 'Unable to delete asset'
+      end
+
+      redirect_to(:back) rescue redirect_to(effective_assets.effective_assets_path)
+    end
+
+  end
+end

data/app/controllers/effective/s3_uploads_controller.rb

@@ -1,98 +1,82 @@
-require 's3_swf_upload'
-require 'base64'
-
 module Effective
   class S3UploadsController < ApplicationController
-    skip_authorize_resource if defined?(CanCan)
-
-    respond_to :js, :xml
-
-    include S3SwfUpload::Signature
-
-    def index
-      # This is actually a 'new' action.  Not an index.  The s3 flash uploader is hardcoded to check this url as an xml request
-
-      EffectiveAssets.authorized?(self, :create, Effective::Asset)
+    skip_authorization_check if defined?(CanCan)
+    skip_before_filter :verify_authenticity_token
 
-      bucket          = EffectiveAssets.aws_bucket
-      access_key_id   = EffectiveAssets.aws_access_key_id
-      acl             = EffectiveAssets.aws_acl
-      secret_key      = EffectiveAssets.aws_secret_access_key
-      key             = params[:key]
-      content_type    = params[:content_type]
-      https           = 'false'
-      error_message   = ''
-      expiration_date = 1.hours.from_now.utc.strftime('%Y-%m-%dT%H:%M:%S.000Z')
+    # When we create an Asset, we're effectively reserving the ID
+    # But the Asset itself isn't really there or uploaded yet.
+    # But we want to start uploading to the final s3 path
 
-      policy = Base64.encode64(
-        "{
-          'expiration': '#{expiration_date}',
-          'conditions': [
-            {'bucket': '#{bucket}'},
-            {'key': '#{key}'},
-            {'acl': '#{acl}'},
-            {'Content-Type': '#{content_type}'},
-            {'Content-Disposition': 'attachment'},
-            ['starts-with', '$Filename', ''],
-            ['eq', '$success_action_status', '201']
-          ]
-        }").gsub(/\n|\r/, '')
+    def create
+      # Here we initialize an empty placeholder Asset, so we can reserve the ID
+      @asset = Effective::Asset.new(:user_id => ((current_user.try(:id) || 1) rescue 1), :upload_file => 'placeholder')
+      @asset.extra = params[:extra] if params[:extra].kind_of?(Hash)
 
-      signature = b64_hmac_sha1(secret_key, policy)
+      EffectiveAssets.authorized?(self, :create, @asset)
 
-      respond_to do |format|
-        format.xml {
-          render :xml => {
-            :policy          => policy,
-            :signature       => signature,
-            :bucket          => bucket,
-            :accesskeyid     => access_key_id,
-            :acl             => acl,
-            :expirationdate  => expiration_date,
-            :https           => https,
-            :errorMessage    => error_message.to_s,
-          }.to_xml
-        }
+      if @asset.save
+        render(:text => {:id => @asset.id, :s3_key => asset_s3_key(@asset)}.to_json, :status => 200)
+      else
+        render(:text => '', :status => 400)
       end
     end
 
-    def create
-      EffectiveAssets.authorized?(self, :create, Effective::Asset)
+    def update
+      @asset = Effective::Asset.find(params[:id])
 
-      # If we're passed Asset information, then create an Asset
-      if params[:file_path].present?
-        asset = Asset.create_from_s3_uploader(params[:file_path],
-          {
-            :title => params[:title],
-            :description => params[:description],
-            :tags => params[:tags],
-            :content_type => params[:content_type],
-            :data_size => params[:file_size],
-            :user_id => current_user.try(:id)
-          }
-        )
-      else
-        asset = (Asset.find(params[:asset_id].to_i) rescue false)
-      end
+      EffectiveAssets.authorized?(self, :update, @asset)
 
-      unless asset
-        render :text => '', :status => :unprocessable_entity
-        return
+      unless params[:skip_update]  # This is useful for the acts_as_asset_box Attach action
+        if update_placeholder_asset(@asset, params) == false
+          render :text => '', :status => :unprocessable_entity
+          return
+        end
       end
 
       # If the attachment information is present, then our input needs some attachment HTML
-      if params.key?(:attachable_type)
-        attachment = Attachment.new
+      if params.key?(:attachable_object_name)
+        attachment = Effective::Attachment.new
         attachment.attachable_type = params[:attachable_type].try(:classify)
-        attachment.attachable_id = params[:attachable_id].try(:to_i) if params[:attachable_id].present? # attachable_id can be nil if we're on a New action
-        attachment.asset_id = asset.try(:id)
+        attachment.attachable_id = params[:attachable_id].try(:to_i)
+        attachment.asset_id = @asset.try(:id)
         attachment.box = params[:box]
         attachment.position = 0
+        attachable_object_name = params[:attachable_object_name].to_s
+        attachment_actions = params[:attachment_actions]
+
+        attachment_partial =
+        case params[:attachment_style].to_s
+        when 'table'
+          'attachment_as_table'
+        when 'list'
+          'attachment_as_list'
+        else # :thumbnail, nil, or anything
+          'attachment_as_thumbnail'
+        end
 
-        render :partial => 'asset_box_input/attachment_fields', :locals => {:attachment => attachment}, :status => 200, :content_type => 'text/html'
+        render :partial => "asset_box_input/#{attachment_partial}", :locals => {:attachment => attachment, :attachable_object_name => attachable_object_name, :attachment_actions => attachment_actions}, :status => 200, :content_type => 'text/html'
       else
         render :text => '', :status => 200
       end
     end
+
+    private
+
+    def update_placeholder_asset(asset, opts)
+      asset.upload_file = opts[:upload_file]
+      asset.data_size = opts[:data_size]
+      asset.content_type = opts[:content_type]
+      asset.title = opts[:title]
+      asset.aws_acl = opts[:aws_acl]
+      asset[:data] = opts[:title]
+
+      # If our S3 Uploader has any issue uploading/saving the asset, destroy the placeholder empty one
+      asset.save ? true : (asset.try(:destroy) and false)
+    end
+
+    def asset_s3_key(asset)
+      "#{EffectiveAssets.aws_path.chomp('/')}/#{asset.id.to_i}/${filename}"
+    end
+
   end
 end

data/app/helpers/effective_assets_helper.rb

@@ -14,42 +14,58 @@ module EffectiveAssetsHelper
     end
 
     opts = opts.merge({:alt => asset.description || asset.title || asset.file_name}).merge(options)
-    image_tag(_effective_asset_image_url(asset, version), opts).gsub('"', "'").html_safe # we need all ' quotes or it breaks Insert as functionality
+
+    content_tag(:img, nil, opts.merge(:src => _effective_asset_image_url(asset, version))).gsub('"', "'").html_safe
   end
 
   def effective_asset_link_to(asset, version = nil, options = {})
-    link_title = asset.title || asset.file_name || asset.description || "Asset ##{asset.id}"
+    options_title = options.delete(:title)
+    link_title = options_title || asset.title || asset.file_name || asset.description || "Asset ##{asset.id}"
 
-    link_to(link_title, asset.url).gsub('"', "'").html_safe # we need all ' quotes or it breaks Insert as functionality
+    if asset.image?
+      link_to(link_title, _effective_asset_image_url(asset, version), options).gsub('"', "'").html_safe # we need all ' quotes or it breaks Insert as functionality
+    else
+      link_to(link_title, asset.url, options).gsub('"', "'").html_safe # we need all ' quotes or it breaks Insert as functionality
+    end
   end
 
   def effective_asset_video_tag(asset)
     render(:partial => 'assets/video', :locals => { :asset => asset }).gsub('"', "'").html_safe # we need all ' quotes or it breaks Insert as functionality
   end
 
+  def effective_asset_title(asset)
+    [
+      asset.title,
+      asset.description,
+      asset.tags,
+      "Size: #{number_to_human_size(asset.data_size)}",
+      "Content Type: #{asset.content_type}"
+    ].compact.join("\n")
+  end
+
   def _effective_asset_image_url(asset, version = nil)
-    return '/assets/mime-types/file.png' if !asset.content_type.present? or asset.content_type == 'unknown'
+    # asset_url and image_url will work in Rails4
+
+    return image_path('mime-types/file.png') if !asset.content_type.present? or asset.content_type == 'unknown'
 
     if asset.icon?
       asset.url
     elsif asset.image?
-      (version == nil or asset.still_processing?) ? asset.url : asset.url.insert(asset.url.rindex('/')+1, "#{version.to_s}_")
+      asset.url(version)
     elsif asset.audio?
-      '/assets/mime-types/mp3.png'
+      image_path('mime-types/mp3.png')
     elsif asset.video?
-      '/assets/mime-types/video.png'
+      image_path('mime-types/video.png')
     elsif asset.content_type.include? 'msword'
-      '/assets/mime-types/word.jpg'
+      image_path('mime-types/word.jpg')
     elsif asset.content_type.include? 'excel'
-      '/assets/mime-types/excel.jpg'
+      image_path('mime-types/excel.png')
     elsif asset.content_type.include? 'application/pdf'
-      '/assets/mime-types/pdf.png'
+      image_path('mime-types/pdf.png')
     elsif asset.content_type.include? 'application/zip'
-      '/assets/mime-types/zip.png'
+      image_path('mime-types/zip.png')
     else
-      '/assets/mime-types/file.png'
+      image_path('mime-types/file.png')
     end
   end
-
-
 end

data/app/helpers/effective_assets_s3_helper.rb

@@ -0,0 +1,69 @@
+module EffectiveAssetsS3Helper
+
+  def s3_uploader_fields(options = {})
+    S3Uploader.new(options).fields.map do |name, value|
+      hidden_field_tag(name, value, :disabled => 'disabled')
+    end.join.html_safe
+  end
+
+  def s3_uploader_url
+    Effective::Asset.s3_base_path.chomp('/') + '/'
+  end
+
+  # Copied and modified from https://github.com/waynehoover/s3_direct_upload/blob/master/lib/s3_direct_upload/form_helper.rb
+  class S3Uploader
+    def initialize(options)
+      @options = options.reverse_merge(
+        aws_access_key_id: EffectiveAssets.aws_access_key_id,
+        aws_secret_access_key: EffectiveAssets.aws_secret_access_key,
+        bucket: EffectiveAssets.aws_bucket,
+        aws_acl: EffectiveAssets.aws_acl,
+        expiration: 10.hours.from_now.utc.iso8601,
+        max_file_size: 1000.megabytes,
+        key_starts_with: "#{EffectiveAssets.aws_path.chomp('/')}/",
+        key: '${filename}' # We use an AJAX request to update this key to a useful value
+      )
+    end
+
+    def fields
+      {
+        :key => @options[:key],
+        :acl => @options[:aws_acl],
+        'AWSAccessKeyId' => @options[:aws_access_key_id],
+        :policy => policy,
+        :signature => signature,
+        :success_action_status => '201',
+        'X-Requested-With' => 'xhr'
+      }
+    end
+
+    def policy
+      Base64.encode64(policy_data.to_json).gsub("\n", "")
+    end
+
+    def policy_data
+      {
+        expiration: @options[:expiration],
+        conditions: [
+          ['starts-with', '$key', @options[:key_starts_with]],
+          ['starts-with', '$x-requested-with', ''],
+          ['content-length-range', 0, @options[:max_file_size]],
+          ['starts-with','$content-type', @options[:content_type_starts_with] || ''],
+          {:bucket => @options[:bucket]},
+          {:acl => @options[:aws_acl]},
+          {:success_action_status => '201'}
+        ] + (@options[:conditions] || [])
+      }
+    end
+
+    def signature
+      Base64.encode64(
+        OpenSSL::HMAC.digest(
+          OpenSSL::Digest::SHA1.new(),
+          @options[:aws_secret_access_key], policy
+        )
+      ).gsub("\n", "")
+    end
+  end
+
+end

data/app/models/concerns/acts_as_asset_box.rb

@@ -37,7 +37,6 @@ module ActsAsAssetBox
     has_many :attachments, :as => :attachable, :class_name => "Effective::Attachment", :dependent => :delete_all
     has_many :assets, :through => :attachments, :class_name => "Effective::Asset"
 
-    #attr_accessible :attachments_attributes
     accepts_nested_attributes_for :attachments, :reject_if => :all_blank, :allow_destroy => true
 
     # Setup validations
@@ -45,9 +44,9 @@ module ActsAsAssetBox
     if boxes.first.kind_of?(Hash) # We were passed some validation requirements
       boxes = boxes.first
 
-      @@acts_as_asset_box_boxes = boxes.keys
-
       boxes.each do |box, validation|
+        self.send(:define_method, box) { assets(box) }
+
         if validation == true
           validates box, :asset_box_presence => true
         elsif validation.kind_of?(Integer) or validation.kind_of?(Range)
@@ -55,11 +54,15 @@ module ActsAsAssetBox
         end
       end
     else
-      @@acts_as_asset_box_boxes = boxes
+      boxes.each do |key|
+        self.send(:define_method, key) { assets(key) }
+      end
     end
 
     class_eval do
       def attachments_attributes=(atts)
+        @last_atts == atts ? return : @last_atts = atts
+
         current_box = ''; position = 0
 
         atts.each do |k, v|
@@ -67,7 +70,7 @@ module ActsAsAssetBox
           atts[k]['position'] = (position += 1) if atts[k]['_destroy'] != '1'
         end
 
-        assign_nested_attributes_for_collection_association(:attachments, atts, {})
+        assign_nested_attributes_for_collection_association(:attachments, atts)
       end
     end
   end
@@ -77,11 +80,12 @@ module ActsAsAssetBox
 
   def assets(box = nil)
     box = (box.present? ? box.to_s : 'assets')
+    boxes = box.pluralize
 
-    if box == box.pluralize
-      attachments.select { |attachment| attachment.box == box }.map { |attachment| attachment.asset }
+    if box == boxes
+      attachments.map { |attachment| attachment.asset if attachment.box == boxes }.compact
     else
-      attachments.to_a.find { |attachment| attachment.box == box.pluralize }.try(:asset)
+      attachments.to_a.find { |attachment| attachment.box == boxes }.try(:asset)
     end
   end
 
@@ -89,9 +93,69 @@ module ActsAsAssetBox
     assets(:asset)
   end
 
-  # This handles all the boxes type function calls
-  def method_missing(method_name, *args, &block)
-    (@@acts_as_asset_box_boxes || []).include?(method_name.to_sym) ? assets(method_name) : super
+  def add_to_asset_box(box, *items)
+    box = (box.present? ? box.to_s : 'assets')
+    boxes = box.pluralize
+    items = [items].flatten.compact
+
+    if items.present? && items.any? { |obj| !obj.kind_of?(Effective::Asset) }
+      raise ArgumentError.new('add_to_asset_box expects one or more Effective::Assets, or an Array of Effective::Assets')
+    end
+
+    if box == boxes # If we're adding to a pluralized box, we want to add our attachment onto the end
+      pos = attachments.select { |attachment| attachment.box == boxes }.last.try(:position).to_i + 1
+    else # If we're adding to a singular box, we want our attachments to be on the front
+      pos = attachments.to_a.find { |attachment| attachment.box == boxes }.try(:position).to_i
+
+      # Push all the attachments forward
+      attachments.each { |att| att.position = (att.position + items.length) if att.box == boxes }
+    end
+
+    # Build the attachments
+    items.each_with_index do |item, x|
+      attachment = self.attachments.build(:position => (pos+x), :box => boxes)
+
+      attachment.attachable = self
+      attachment.asset = item
+    end
+
+    attachments.to_a.sort_by!(&:position)
+
+    true
+  end
+
+  def add_to_asset_box!(box, *items)
+    add_to_asset_box(box, items) && save!
+  end
+
+  # The idea here is that if you want to replace an Asset with Another one
+  # the Attachment should keep the same order, and only the asset should change
+
+  def replace_in_asset_box(box, original, overwrite)
+    box = (box.present? ? box.to_s : 'assets')
+    boxes = box.pluralize
+
+    unless original.present? && original.kind_of?(Effective::Asset)
+      raise ArgumentError.new("second parameter 'original' must be a single Effective::Asset")
+    end
+
+    unless overwrite.present? && overwrite.kind_of?(Effective::Asset)
+      raise ArgumentError.new("third parameter 'overwrite' must be a single Effective::Asset")
+    end
+
+    attachment = attachments.to_a.find { |attachment| attachment.box == boxes && attachment.asset == original }
+
+    if attachment.present?
+      attachment.asset = overwrite
+      true
+    else
+      false
+    end
+  end
+
+  def replace_in_asset_box!(box, original, overwrite)
+    replace_in_asset_box(box, original, overwrite) && save!
   end
+
 end