acts_as_assets 0.1.1 → 0.2.0

data/README.md

@@ -0,0 +1,3 @@
+= ActsAsAssets
+
+This project rocks and uses MIT-LICENSE.

data/app/controllers/acts_as_assets/assets_controller.rb

@@ -1,37 +1,46 @@
 class ActsAsAssets::AssetsController < ApplicationController
   include ActsAsAssets::AssetsHelper
   helper_method :destroy_path
-  before_filter "assign_root_model"
-  before_filter "assign_target", :only => [:index,:destroy]
+
+  before_filter :load_type
+  before_filter :assign_target, :only => [:index, :destroy]
+  before_filter :load_assets, :only => [:index, :destroy]
 
   def index
-    load_assets
+    puts "klazz.base_model: #{klazz.base_model}"
+    puts "klazz.foreign_key_name: #{klazz.foreign_key_name}"
+    puts "params[klazz.foreign_key_name]: #{params[klazz.foreign_key_name]}"
+    puts "klazz.base_model.find(CGI.unescape(params[klazz.foreign_key_name])): #{klazz.base_model.find(CGI.unescape(params[klazz.foreign_key_name]))}"
+    @model = klazz.base_model.find(CGI.unescape(params[klazz.foreign_key_name]))
     respond_to do |format|
-      format.html{render :layout => false}
-      format.json{render :json => @assets}
+      format.html { render :layout => false }
+      format.json { render :json => @assets }
     end
   end
 
   def create
-    name = root_model_name
-    klazz = ([name.pluralize.camelize] << camelize_type.flatten).join('::')
-    @asset = klazz.constantize.create(:asset => params[:file],
-                                      :asset_content_type => MIME::Types.type_for(params[:file].original_filename)[0].to_s,
-                                      "#{name}".to_sym => instance_variable_get("@#{name}".to_sym))
+    @model = klazz.base_model.find(CGI.unescape(params[klazz.foreign_key_name]))
+    @asset = klazz.create(
+            :asset => params[:file],
+            :asset_content_type => mime_type(params[:file]),
+            klazz.base_model_sym => @model)
 
+    @asset_partial = partial_to_use(@asset)
     respond_to do |format|
       if @asset.valid?
+        load_assets
         format.js
       else
-        format.js { render :json =>{:success => false, :errors => @asset.errors}}
+        format.js { render :json => {:success => false, :errors => @asset.errors} }
       end
     end
   end
 
   def destroy
-
     begin
-      @asset = instance_variable_get("@#{root_model_name}").send(:assets).find_by_id(params[:asset_id])
+      @model = klazz.base_model.find(CGI.unescape(params[klazz.foreign_key_name]))
+      @asset = klazz.find_by_id(params[:asset_id])
+      @asset_partial = partial_to_use(@asset)
       @asset.destroy
     rescue Exception => e
       error = e.message
@@ -41,7 +50,7 @@ class ActsAsAssets::AssetsController < ApplicationController
       if error.nil?
         format.js
       else
-        format.js { render :json => {:success => false, :errors => error}}
+        format.js { render :json => {:success => false, :errors => error} }
       end
     end
 
@@ -49,42 +58,50 @@ class ActsAsAssets::AssetsController < ApplicationController
 
   def get
     begin
-      @asset = instance_variable_get("@#{root_model_name}").send(:assets).find(params[:asset_id])
+      @asset = klazz.find(params[:asset_id])
+
+      send_file(file_to_download_path, {:filename => @asset.asset.to_file.original_filename, :content_type => @asset.asset_content_type, :disposition => 'inline'})
+
     rescue ActiveRecord::RecordNotFound
-      respond_with_404  and return
+      respond_with_404
     end
-    @path = params[:style].nil? ? @asset.asset.path : @asset.asset.path(params[:style])
-    send_file(@path, {:filename => @asset.asset.to_file.original_filename, :content_type => @asset.asset_content_type, :disposition => 'inline'})
   end
 
-
   private
+  def file_to_download_path
+    @path = params[:style].nil? ? @asset.asset.path : @asset.asset.path(params[:style])
+  end
+
+  def partial_to_use(asset)
+    asset.multiple? ? "acts_as_assets/assets/asset_multiple_upload" : "acts_as_assets/assets/asset_upload"
+  end
 
   def load_assets
-    name = root_model_name
-    klazz = ([name.pluralize.camelize] << camelize_type.flatten).join('::')
-    @assets = klazz.constantize.send(:where,"#{name}_id".to_sym => params["#{name}_id".to_sym])
+    @assets = klazz.where(klazz.foreign_key_name => CGI.unescape(params[klazz.foreign_key_name]))
   end
 
-  def assign_root_model
-    name = root_model_name
-    instance_variable_set "@#{name}", name.camelize.constantize.send(:find, params["#{name}_id".to_sym])
+  def klazz
+    ([self.class.to_s.split('::').first] << camelize_type).join('::').constantize
   end
 
-  def root_model_name
-    ActiveSupport::Inflector.underscore(self.class.to_s.split('::').first.singularize)
+  ## takes a type params string like "my/asset/type_of_documento" and convert into [My,Asset,TypeOfDocument]
+  def camelize_type
+    params[:type].split('/').map { |i| i.camelize }.flatten
   end
 
   def assign_target
     @target = params[:target]
   end
 
-  # takes a type params string like "my/asset/type_of_documento" and convert into [My,Asset,TypeOfDocument]
-  def camelize_type
-    params[:type].split('/').collect{|i|i.camelize}
+  def mime_type(file)
+    MIME::Types.type_for(file.original_filename)[0].to_s
+  end
+
+  def load_type
+    raise ":type of asset is mandatory and not specified" unless params[:type]
+    @type = params[:type]
   end
 
-  private
 
   def respond_with_404
     render :file => "#{Rails.root}/public/404.html", :status => :not_found

data/app/helpers/acts_as_assets/assets_helper.rb

@@ -1,9 +1,52 @@
 module ActsAsAssets::AssetsHelper
+  def destroy_path(asset, model, target, type)
+    send(destroy_method_for(asset), model, {:asset_id => asset.id, :target => target, :type => type})
+  end
+
+  def destroy_method_for(asset)
+    "#{name_from(asset)}_destroy_asset_path".to_sym
+  end
+
+  def name_from(asset)
+    asset.class.base_model_name
+  end
+
+  def asset_target
+    @type.split('/').join('_')
+  end
+
+  def upload_complete_js_function
+    "function(id, fileName, responseJSON, qq){K.allegati.onComplete(id, fileName, responseJSON, qq,'#{asset_target}');}"
+  end
+  def asset_action(model)
+    method_name = "#{model.class.model_name.split('::').first.underscore.singularize}_create_asset_path".to_sym
+    self.send(method_name, model, :type => @type, :format => :js)
+  end
 
-  def destroy_path doc, target
-    name = ActiveSupport::Inflector.underscore(doc.class.to_s.split('::').first.singularize)
-    method = "#{name}_destroy_asset_path"
-    send(method.to_sym, instance_variable_get("@#{name}"), :asset_id => doc.id, :target => target)
+  def destroy_file_path(asset, model)
+    destroy_path(asset, model, asset_target, @type)
   end
 
+  def destroy_link(asset, model)
+    link_to(I18n.translate('destroy'), destroy_file_path(asset, model), {:method => :delete, :confirm => 'Sei Sicuro?', :remote => true})
+  end
+
+  def asset_label
+    defined?(type_label).nil? ? @type.split('/').last.to_s.humanize : type_label
+  end
+
+  def asset_id
+    asset_target
+  end
+
+  def asset_file_name(asset)
+    asset.asset.to_file.original_filename
+  end
+  def asset_file_path(asset)
+    asset.asset.url
+  end
+
+  def assets_body
+    j render(:partial => @asset_partial, :locals => {:assets => Array(@assets), :model => @model})
+  end
 end

data/app/views/acts_as_assets/assets/_asset.html.erb

@@ -0,0 +1,12 @@
+<% if asset.displayable? %>
+    <li>
+        <%= link_to("#{asset.asset.url(:original)}&type=#{URI.encode(@type)}", :class => "zoom", :rel => "immagine_sito") {image_tag("#{asset.asset.url(:thumb)}&type=#{URI.encode(@type)}", :alt => 'Apri Immagine')}%>
+        <div><%= asset.asset.to_file.original_filename %></div>
+        <%= destroy_link(asset, model) %>
+    </li>
+<% else %>
+    <li>
+        <%= link_to(asset.asset.to_file.original_filename, "#{asset.asset.url}&type=#{@type}") %>
+        <%= destroy_link(asset, model) %>
+    </li>
+<% end %>

data/app/views/acts_as_assets/assets/_asset_multiple_upload.html.erb

@@ -0,0 +1,6 @@
+<%# encoding: utf-8 %>
+<% assets ||= @assets %>
+<div id="<%=asset_id%>" class="multiple assets">
+    <%= render :partial => "acts_as_assets/assets/upload_link", :locals => {:multiple => true, :model => model} %>
+    <%= render :partial => "acts_as_assets/assets/assets", :locals => {:assets => Array(assets), :model => model} %>
+</div>

data/app/views/acts_as_assets/assets/_asset_upload.html.erb

@@ -0,0 +1,9 @@
+<%# encoding: utf-8 %>
+<% assets ||= @assets %>
+<div id="<%=asset_id%>" class="multiple assets">
+<% if Array(assets).empty? %>
+    <%= render :partial => "acts_as_assets/assets/upload_link", :locals => {:multiple => false, :model => model} %>
+<% else %>
+    <%= render :partial => "acts_as_assets/assets/assets", :locals => {:assets => Array(assets), :model => model} %>
+<% end %>
+</div>

data/app/views/acts_as_assets/assets/_assets.html.erb

@@ -0,0 +1,6 @@
+<ul>
+    <%= render :partial => 'acts_as_assets/assets/asset', :collection => assets, :locals => {:model => model} %>
+</ul>
+<script type="text/javascript">
+    $(function () { $("a.zoom").fancybox(); });
+</script>

data/app/views/acts_as_assets/assets/_upload_link.html.erb

@@ -0,0 +1,6 @@
+<%= uploader_field_tag asset_target,
+                       :action => asset_action(model),
+                       :uploadButtonText => t('aggiungi'),
+                       :multiple => multiple,
+                       :params => {:authenticity_token => form_authenticity_token, :target => asset_target},
+                       :onComplete => upload_complete_js_function %>

data/app/views/acts_as_assets/assets/create.js.erb

@@ -1 +1 @@
-{"success":"true"}
+{"asset_id": "<%= asset_id %>","body": "<%= assets_body %>","success": true}

data/app/views/acts_as_assets/assets/destroy.js.erb

@@ -1 +1 @@
-{"success":"true"}
+$("#<%= asset_id %>").html("<%= assets_body %>");

data/app/views/acts_as_assets/assets/index.html.erb

@@ -1,12 +1,2 @@
-<%# coding: utf-8 %>
-<% @assets.each do |doc| %>
-
-    <div class="grid_6 document_link">
-            <%= link_to doc.asset.to_file.original_filename, doc.asset.url %>
-            <%= link_to t('destroy'), destroy_path(doc,@target),
-                       :method => :delete, :confirm => 'Sei Sicuro?', :remote => true %>
-    </div>
-
-    <div class="clear"></div>
-
-<% end %>
+<%# encoding: utf-8 %>
+<% render :partial => 'acts_as_assets/assets/asset_multiple_upload', :locals => {:model => @model, :multiple => true} %>

data/config/initializers/inflections.rb

@@ -0,0 +1,14 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'tipo_pannello', 'tipi_pannello'
+end

data/config/locales/it.yml

@@ -1,3 +1,3 @@
 it:
-    acts_as_assets:
-        unique_asset_error: 'Un solo documento di questo tipo può essere caricato. Eliminare il file attuale per sostituirlo.'
+  acts_as_assets:
+    unique_asset_error: 'Un solo documento di questo tipo può essere caricato. Eliminare il file attuale per sostituirlo.'

data/lib/acts_as_assets/base.rb

@@ -1,73 +1,112 @@
 require "acts_as_assets/paperclip/interpolations"
 require "acts_as_assets/unique_asset"
+require "h5_uploader"
 
 module ActsAsAssets
 
   module Base
+    extend ActiveSupport::Concern
 
-    def self.included base
-      base.class_eval do
-        extend ClassMethods
-      end
+    included do
+      extend ClassMethods
     end
-
   end
 
   module ClassMethods
 
     def acts_as_assets *args
+      cattr_accessor :foreign_key_name
+      cattr_accessor :base_model_name
+      cattr_accessor :base_model
+
       include InstanceMethods
-      belongs_to root_model
 
       options = args.extract_options!
+
       paperclip_config = {
-          :url => options.include?(:styles) ?
-              "/#{root_model.to_s.pluralize}/:acts_as_assets_root_id/assets/get/:acts_as_assets_asset_id/:style/:acts_as_assets_file_name.:extension" :
-              "/#{root_model.to_s.pluralize}/:acts_as_assets_root_id/assets/get/:acts_as_assets_asset_id/:acts_as_assets_file_name.:extension",
-          :path => options.include?(:styles) ? ":acts_as_assets_file_path/:style/:acts_as_assets_file_name.:extension" : ":acts_as_assets_file_path/:acts_as_assets_file_name.:extension"
+          :url => options.include?(:styles) ? url_with_styles : url_without_styles,
+          :path => options.include?(:styles) ? path_with_styles : path_without_styles
       }
+      self.base_model_name = self.to_s.split('::').first.underscore.singularize
+      self.base_model = self.base_model_name.camelize.constantize
+      self.foreign_key_name = (options[:foreign_key] || "#{self.base_model_name}_id").to_sym
+
+      belongs_to base_model_sym, :foreign_key => self.foreign_key_name
       has_attached_file :asset, paperclip_config.merge(options)
-      before_create :touch_counter
+
+      before_create :increment_counter
+
+    end
+
+    def url_with_styles
+      "/#{_base_model_name.pluralize}/:acts_as_assets_root_id/assets/get/:acts_as_assets_asset_id/:style/:acts_as_assets_file_name.:extension"
+    end
+
+    def url_without_styles
+      "/#{_base_model_name.pluralize}/:acts_as_assets_root_id/assets/get/:acts_as_assets_asset_id/:acts_as_assets_file_name.:extension"
+    end
+
+    def path_with_styles
+      ":acts_as_assets_file_path/:style/:acts_as_assets_file_name.:extension"
+    end
+
+    def path_without_styles
+      ":acts_as_assets_file_path/:acts_as_assets_file_name.:extension"
+    end
+
+    def _base_model_name
+      self.to_s.split('::').first.underscore.singularize
     end
 
-    def root_model
-      ActiveSupport::Inflector.underscore(self.to_s.split('::').first.singularize).to_sym
+    def base_model_sym
+      _base_model_name.to_sym
     end
 
   end
 
   module InstanceMethods
-
     def acting_as_assets?
       true
     end
 
+    def multiple?
+      true
+    end
+
     private
+    def increment_counter
+      self.counter = number_of_file_for_type + 1
+    end
 
-    def touch_counter
-      max = self.class.maximum(:counter, :conditions => {"#{self.class.root_model}_id".to_sym => self.send("#{self.class.root_model}_id".to_sym)})
-      self.counter = max.nil? ? 1 : max+1
+    def number_of_file_for_type
+      self.class.maximum(:counter, :conditions => {self.foreign_key_name => self.send(self.foreign_key_name)}).to_i
     end
 
-    def root_id
-      send(self.class.root_model).id
+    def foreign_key_value
+      self.send(foreign_key_name)
     end
 
     def acts_as_assets_file_path
-      a = ActiveSupport::Inflector.underscore(self.type).split('/').prepend "public", "system"
-      a.pop
-      root_model_index = a.index(self.class.root_model.to_s.pluralize)
-      a.insert root_model_index + 1,root_id
-      a.join '/'
+      absolute_directory_for_asset_as_array.insert(3, foreign_key_value).join('/')
     end
 
     def acts_as_assets_file_name
-      a = ActiveSupport::Inflector.underscore(self.type).split('/')
-      self.counter > 1 ? "#{a.last}_#{counter}" : a.last
+      self.counter > 1 ? "#{_file_name}_#{counter}" : _file_name
+    end
+
+    def _file_name
+      relative_directory_for_asset_as_array.last
     end
 
+    def relative_directory_for_asset_as_array
+      self.type.underscore.split('/')
+    end
+
+    def absolute_directory_for_asset_as_array
+      relative_directory_for_asset_as_array.unshift("public", "system").instance_eval { pop; self }
+    end
   end
 
 end
 
-ActiveRecord::Base.send :include, ActsAsAssets::Base
+ActiveRecord::Base.send :include, ActsAsAssets::Base

data/lib/acts_as_assets/engine.rb

@@ -1,4 +1,7 @@
 module ActsAsAssets
   class Engine < ::Rails::Engine
+    initializer "acts_as_assets.add_form_builder_extensions", :after=>"bootstrap_hook" do |app|
+      require "acts_as_assets/form_helper"
+    end
   end
 end

data/lib/acts_as_assets/form_helper.rb

@@ -0,0 +1,42 @@
+module ActionView
+  module Helpers
+    class FormBuilder
+      def asset_upload(method, type)
+        @template.asset_upload_tag(@object, method, type)
+      end
+      def asset_multiple_upload(method, type)
+        @template.asset_multiple_upload_tag(@object, method, type)
+      end
+      def asset_label(method, type)
+        @template.asset_label_tag(@object, method, type)
+      end
+    end
+
+    module FormTagHelper
+      def asset_multiple_upload_tag(model, methods, type)
+        asset_upload_helper(model, methods, type, "acts_as_assets/assets/asset_multiple_upload")
+      end
+
+      def asset_upload_tag(model, methods, type)
+        asset_upload_helper(model, methods, type, "acts_as_assets/assets/asset_upload")
+      end
+
+      private
+
+      # +methods+ can be a sym that will be the method name and it will be called
+      # against the model passed or can an array of symbols and will be chained in a method call
+      # for instance
+      # asset_upload_tag(@pratica, [:back_office, :allegati], ...)
+      # will call @pratica.back_office.allegati
+      def asset_upload_helper(model, methods, type, partial)
+        render :partial => partial,
+               :locals => {:@type => type, :model => model, :assets => model_assets(methods, model)}
+      end
+
+      def model_assets(methods, model)
+        Array(methods).inject(model) {|object, method| object.send(method) }
+      end
+
+    end
+  end
+end