gluttonberg-core 2.6.4 → 3.0.0

data/app/assets/stylesheets/user-styles.sass

@@ -1,3 +0,0 @@
-.test
-  :color green
-  

data/app/controllers/gluttonberg/admin/asset_library/assets_ajax_controller.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module AssetLibrary
+      class AssetsAjaxController < Gluttonberg::Admin::AssetLibrary::BaseController
+        # Create asset for ajax request from asset selector
+        def create
+          handle_blank_asset_name
+          # process new asset_collection and merge into existing collections
+          AssetCollection.process_new_collection_and_merge(params, current_user)
+          prepare_new_asset_object
+          if @asset.save
+            render :text  => @asset.to_json_for_ajax_new.to_s
+          else
+            prepare_to_edit
+            render :new
+          end
+        end
+
+        # expand an asset collection
+        def browser_collection
+          @collection = AssetCollection.where(:id => params[:id]).first
+          @category_filter =  params[:filter] || "all"
+          @assets = AssetCategory.find_assets_by_category_and_collection(@category_filter, @collection)
+          render :layout => false
+        end
+
+        # Filter assets by a selected date in asset selector
+        def filter_assets_by_date
+          unless params[:asset_date_filter].blank?
+            date = Time.zone.parse(params[:asset_date_filter])
+            @search_assets = Asset.where(["created_at between ? AND ?", date.beginning_of_day, date.end_of_day ] )
+            respond_to do |format|
+              format.html do
+                @search_assets = @search_assets.paginate({
+                  :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"),
+                  :page => params[:page]
+                })
+              end
+              format.json do 
+                render :template => "/gluttonberg/admin/asset_library/assets/search.json.haml"
+              end
+            end
+          end
+        end
+
+        private
+          def handle_blank_asset_name
+            @blank_asset_name = false
+            if params[:asset][:name].blank?
+              params[:asset][:name] = "Asset #{Time.now.to_i}"
+              @blank_asset_name = true
+            end
+          end
+
+          def prepare_new_asset_object
+            @asset = Asset.new(params[:asset])
+            @asset.user_id = current_user.id
+            @asset.name = @asset.file_name.humanize if @blank_asset_name
+          end
+      end
+    end #AssetLibrary
+  end
+end

data/app/controllers/gluttonberg/admin/asset_library/assets_bulk_controller.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module AssetLibrary
+      class AssetsBulkController < Gluttonberg::Admin::AssetLibrary::BaseController
+        record_history :@asset
+
+        def destroy_assets_in_bulk
+          @assets = Asset.where(:id => params[:asset_ids].split(",")).all
+          @assets.each do |asset|
+            authorize! :destroy, asset
+            asset.destroy
+          end
+          redirect_to admin_asset_category_path(:category => 'all' , :page => 1 )
+        end
+
+        # add assets from zip folder
+        def add_assets_in_bulk
+          @asset = Asset.new
+        end
+
+        # create assets from zip
+        def create_assets_in_bulk
+          # process new asset_collection and merge into existing collections
+          AssetCollection.process_new_collection_and_merge(params, current_user)
+          @asset = Asset.new(params[:asset])
+          if @asset.valid?
+            @new_assets = AssetBulkImport.open_zip_file_and_make_assets(params[:asset], current_user)
+            if @new_assets.blank?
+              flash[:error] = "The zip file you uploaded does not have any valid files."
+              prepare_to_edit
+              render :action => :add_assets_in_bulk
+            else
+              flash[:notice] = "All valid assets have been successfully saved."
+            end
+          else
+            prepare_to_edit
+            flash[:error] = "The zip file you uploaded is not valid."
+            render :action => :add_assets_in_bulk
+          end
+        end
+
+      end # controller
+    end
+  end
+end

data/app/controllers/gluttonberg/admin/asset_library/assets_controller.rb

@@ -3,134 +3,60 @@
 module Gluttonberg
   module Admin
     module AssetLibrary
-      class AssetsController < Gluttonberg::Admin::BaseController
-        before_filter :find_categories, :except => [:delete, :destroy]
+      class AssetsController < Gluttonberg::Admin::AssetLibrary::BaseController
         before_filter :find_asset , :only => [:crop , :save_crop , :delete , :edit , :show , :update , :destroy  ]
-        before_filter :prepare_to_edit  , :except => [:category , :show , :delete , :create , :update  ]
-        before_filter :authorize_user
-        before_filter :authorize_user_for_destroy , :except => [:destroy , :delete]
+        before_filter :authorize_user , :except => [:destroy , :delete]
+        before_filter :authorize_user_for_destroy , :only => [:destroy , :delete]
+        before_filter :authorize_user_for_edit , :only => [:edit , :update, :crop, :save_crop]
+
         record_history :@asset
         include Gluttonberg::ApplicationHelper
 
         # home page of asset library
         def index
-
+          redirect_to admin_asset_category_path(:category => 'all' , :page => 1 )
         end
 
 
         def search
           unless params[:asset_query].blank?
-            command = "like"
-            if ActiveRecord::Base.configurations[Rails.env]["adapter"] == "postgresql"
-              command = "ilike"
-            end
-            query = clean_public_query(params[:asset_query])
-            @search_assets = Asset.where(["name #{command} ? OR description LIKE ? ", "%#{query}%" , "%#{query}%" ] ).order("name ASC")
+            @search_assets = Asset.search_assets(clean_public_query(params[:asset_query]))
             respond_to do |format|
-              format.html{
-                page = params[:page].blank? ? 1 : params[:page].to_i
-                @search_assets = @search_assets.paginate(:per_page => 15 , :page => page )
-              }
-              format.json {
-
-              }
+              format.html do
+                @search_assets = @search_assets.paginate({
+                  :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"),
+                  :page => params[:page]
+                })
+              end
+              format.json
             end
           end
-
         end
 
         # if filter param is provided then it will only show filtered type
         def browser
+          prepare_to_edit
           # Get the latest assets
-          @assets = Asset.order("created_at DESC").includes(:asset_type).limit(20)
-
-          @category_filter = ( params[:filter].blank? ? "all" : params[:filter] )
-          if @category_filter == "all"
-          else
-            @category = AssetCategory.find(:first , :conditions => { :name => @category_filter })
-            @assets = @assets.where({:asset_type_id => @category.asset_type_ids }) unless @category.blank? || @category.asset_type_ids.blank?
-          end
-
-          if params["no_frame"]
-            render :partial => "browser_root"
-          else
-            render :layout => false
-          end
-        end
-
-        def browser_collection
-          @collection = AssetCollection.find(params[:id])
-          @category_filter = ( params[:filter].blank? ? "all" : params[:filter] )
-          if @category_filter == "all"
-            @assets = @collection.assets
-          else
-            @category = AssetCategory.where({ :name => @category_filter }).first
-            @assets = @collection.assets.where({:asset_type_id => @category.asset_type_ids }) unless @category.blank? || @category.asset_type_ids.blank?
-          end
-          render :layout => false
+          @category_filter = params[:filter] || "all"
+          @assets = AssetCategory.find_assets_by_category(@category_filter).order("created_at DESC").limit(20)
+          render(params["no_frame"] ? {:partial => "browser_root"} : {:layout => false})
         end
 
         # list assets page by page if user drill down into a category from category tab of home page
         def category
           params[:category] = params[:category].downcase.singularize unless params[:category].blank?
-          params[:order_type] = (params[:order_type].blank? ? "desc" : params[:order_type])
-          if params[:category] == "all" then
-            # ignore asset category if user selects 'all' from category
-            @assets = Asset.includes(:asset_type)
-          else
-            req_category = AssetCategory.first(:conditions => "name = '#{params[:category]}'" )
-            # if category is not found then raise exception
-            if req_category.blank?
-              raise ActiveRecord::RecordNotFound
-            else
-              @assets = req_category.assets.includes(:asset_type)
-            end
-          end # category#all
-          page = params[:page].blank? ? 1 : params[:page].to_i
-          @assets = @assets.paginate( :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items") , :page => page ).order(get_order)
+          params[:order_type] = params[:order_type] || "desc"
+          @assets = AssetCategory.find_assets_by_category(params[:category])
+          @assets = @assets.paginate({
+            :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"),
+            :page => params[:page]
+          }).order(get_order)
         end
 
 
         def show
         end
 
-        def destroy_assets_in_bulk
-          @assets = Asset.where(:id => params[:asset_ids].split(",")).all
-          @assets.each do |asset|
-            asset.destroy
-          end
-          redirect_to "/admin/browse/all/page/1"
-        end
-
-        # add assets from zip folder
-        def add_assets_in_bulk
-          @asset = Asset.new
-        end
-
-        # create assets from zip
-        def create_assets_in_bulk
-          @new_assets = []
-          if request.post?
-            # process new asset_collection and merge into existing collections
-            process_new_collection_and_merge(params)
-            @asset = Asset.new(params[:asset])
-            if @asset.valid?
-              open_zip_file_and_make_assets()
-              if @new_assets.blank?
-                flash[:error] = "The zip file you uploaded does not have any valid files."
-                prepare_to_edit
-                render :action => :add_assets_in_bulk
-              else
-                flash[:notice] = "All valid assets have been successfully saved."
-              end
-            else
-              prepare_to_edit
-              flash[:error] = "The zip file you uploaded is not valid."
-              render :action => :add_assets_in_bulk
-            end
-          end
-        end
-
         # new asset
         def new
           @asset = Asset.new
@@ -152,7 +78,7 @@ module Gluttonberg
 
         # delete asset
         def delete
-          return_url = "/admin/browse/all/page/1"
+          return_url = admin_asset_category_path(:category => 'all' , :page => 1 )
           return_url =  request.referrer unless request.referrer.blank?
           display_delete_confirmation(
             :title      => "Delete “#{@asset.name}” asset?",
@@ -164,13 +90,13 @@ module Gluttonberg
         # create individual asset
         def create
           # process new asset_collection and merge into existing collections
-          process_new_collection_and_merge(params)
+          AssetCollection.process_new_collection_and_merge(params, current_user)
 
           @asset = Asset.new(params[:asset])
           @asset.user_id = current_user.id
           if @asset.save
             flash[:notice] = "The asset was successfully created."
-            redirect_to(admin_asset_url(@asset))
+            redirect_to(admin_asset_path(@asset))
           else
             prepare_to_edit
             render :new
@@ -180,11 +106,11 @@ module Gluttonberg
         # update asset
         def update
           # process new asset_collection and merge into existing collections
-          process_new_collection_and_merge(params)
+          AssetCollection.process_new_collection_and_merge(params, current_user)
 
           if @asset.update_attributes(params[:asset])
             flash[:notice] = "The asset was successfully updated."
-            redirect_to(admin_asset_url(@asset))
+            redirect_to(admin_asset_path(@asset))
           else
             prepare_to_edit
             flash[:error] = "Sorry, The asset could not be updated."
@@ -199,181 +125,32 @@ module Gluttonberg
           else
             flash[:error] = "There was an error deleting the asset."
           end
-          if !params[:return_url].blank? && !params[:return_url].include?(admin_asset_path(params[:id]))
+          if params[:return_url].blank? && !params[:return_url].include?(admin_asset_path(params[:id]))
             redirect_to params[:return_url]
           else
-            redirect_to "/admin/browse/all/page/1"
+            redirect_to admin_asset_category_path(:category => 'all' , :page => 1 )
           end
         end
 
-        def ajax_new
-          empty_file_name = false
-          if(params[:asset][:name].blank?)
-            params[:asset][:name] = "Asset #{Time.now.to_i}"
-            empty_file_name = true
+        private
+          def find_asset
+            @asset = Asset.where(:id => params[:id]).first
+            raise ActiveRecord::RecordNotFound if @asset.blank?
           end
-          # process new asset_collection and merge into existing collections
-          process_new_collection_and_merge(params)
 
-          @asset = Asset.new(params[:asset])
-          @asset.user_id = current_user.id
-          if empty_file_name
-            @asset.name = @asset.file_name.humanize
-          end
-          if @asset.save
-            if @asset.category == "image"
-              render :text => { "asset_id" => @asset.id , "url" => @asset.thumb_small_url , "jwysiwyg_image" => @asset.url_for(:jwysiwyg_image) , "title" => @asset.name , "category" => @asset.category }.to_json.to_s
-            else
-              render :text => { "asset_id" => @asset.id , "url" => @asset.url , "jwysiwyg_image" => @asset.url_for(:jwysiwyg_image) , "title" => @asset.name , "category" => @asset.category }.to_json.to_s
-            end
-          else
-            prepare_to_edit
-            render :new
+          def authorize_user
+            authorize! :manage, Gluttonberg::Asset
           end
-        end
-
-        private
-            def find_asset
-              conditions = { :id => params[:id] }
-              @asset = Asset.find(:first , :conditions => conditions )
-              raise ActiveRecord::RecordNotFound  if @asset.blank?
-            end
-
-            def find_categories
-              @categories = AssetCategory.all
-            end
-
-            def prepare_to_edit
-              @collections = AssetCollection.order("name")
-            end
-
-            def authorize_user
-              authorize! :manage, Gluttonberg::Asset
-            end
-
-            def authorize_user_for_destroy
-              authorize! :destroy, Gluttonberg::Asset
-            end
-
-            # if new collection is provided it will create the object for that
-            # then it will add new collection id into other existing collection ids
-            def process_new_collection_and_merge(params)
-              params[:asset][:asset_collection_ids] = "" if params[:asset][:asset_collection_ids].blank? || params[:asset][:asset_collection_ids] == "null"  || params[:asset][:asset_collection_ids] == "undefined"
-              params[:asset][:asset_collection_ids] = params[:asset][:asset_collection_ids].split(",") if params[:asset][:asset_collection_ids].kind_of?(String)
-
-              the_collection = find_or_create_asset_collection_from_hash(params["new_collection"])
-               unless the_collection.blank?
-                 params[:asset][:asset_collection_ids] = params[:asset][:asset_collection_ids] || []
-                 unless params[:asset][:asset_collection_ids].include?(the_collection.id.to_s)
-                   params[:asset][:asset_collection_ids] <<  the_collection.id
-                 end
-               end
-            end
-
-             # Returns an AssetCollection (either by finding a matching existing one or creating a new one)
-             # requires a hash with the following keys
-             #   do_new_collection: If not present the method returns nil and does nothing
-             #   new_collection_name: The name for the collection to return.
-             def find_or_create_asset_collection_from_hash(param_hash)
-               # Create new AssetCollection if requested by the user
-               if param_hash
-                   if param_hash.has_key?('new_collection_name')
-                     unless param_hash['new_collection_name'].blank?
-                       #create options for first or create
-                       options = {:name => param_hash['new_collection_name'] }
-
-                       # Retireve the existing AssetCollection if it matches or create a new one
-                       the_collection = AssetCollection.find(:first , :conditions => options)
-                       unless the_collection
-                         the_collection = AssetCollection.new(options)
-                         the_collection.user_id = current_user.id
-                         the_collection.save
-                       end
-
-                       the_collection
-                     end # new_collection_name value
-                   end # new_collection_name key
-                 end # param_hash
-             end # find_or_create_asset_collection_from_hash
 
+          def authorize_user_for_destroy
+            authorize! :destroy, @asset
+          end
 
-            # makes a new folder (name of the folder is current time stamp) inside tmp folder
-            # open zip folder
-            # iterate on opened zip folder and make assets for each entry using  make_asset_for_entry method
-            # removes directory which we made inside tmp folder
-            # also removes zip tmp file
-            def open_zip_file_and_make_assets
-              zip = params[:asset][:file]
-              dir = File.join(Rails.root,"tmp")
-              dir = File.join(dir,Time.now.to_i.to_s)
-
-              FileUtils.mkdir_p(dir)
-
-              begin
-                Zip::ZipFile.open(zip.tempfile.path).each do |entry|
-                  make_asset_for_entry(entry , dir)
-                end
-                zip.tempfile.close
-              rescue => e
-                Rails.logger.info e
-              end
-              FileUtils.rm_r(dir)
-              FileUtils.remove_file(zip.tempfile.path)
-            end
-
-            # taskes zip_entry and dir path. makes assets if its valid then also add it to @new_assets list
-            # its responsible of extracting entry and its deleting it.
-            # it use file name for making asset.
-            def make_asset_for_entry(entry , dir)
-              begin
-                filename = File.join(dir,entry.name)
-
-                unless entry.name.starts_with?("._") || entry.name.starts_with?("__") || entry.directory?
-                  entry.extract(filename)
-                  file = MyFile.init(filename , entry)
-                  asset_name_with_extention = entry.name.split(".").first
-                  asset_name_with_extention = asset_name_with_extention.humanize
-                  asset_name_with_extention = asset_name_with_extention.gsub('-',' ')
-                  asset = Asset.new(params[:asset].merge( :name => asset_name_with_extention ,  :file => file ) )
-                  asset.user_id = current_user.id
-                  @new_assets << asset if asset.save
-                  file.close
-                  FileUtils.remove_file(filename)
-                end
-              rescue => e
-                  Rails.logger.info e
-              end
-            end
-
+          def authorize_user_for_edit
+            authorize! :edit, @asset
+          end
 
       end # controller
     end
   end
 end
-# i made this class for providing extra methods in file class.
-# I am using it for making assets from zip folder.
-# keep in mind when we upload asset from browser, browser injects three extra attributes (that are given in MyFile class)
-# but we are adding assets from file, i am injecting extra attributes manually. because asset library assumes that file has three extra attributes
-class MyFile < File
-  attr_accessor :original_filename , :content_type , :size
-
-  def self.init(filename , entry)
-    file = MyFile.new(filename)
-    file.original_filename = filename
-    file.content_type = find_content_type(filename)
-    file.size = entry.size
-    file
-  end
-
-  def tempfile
-    self
-  end
-  def self.find_content_type(filename)
-    begin
-     MIME::Types.type_for(filename).first.content_type
-    rescue
-      ""
-    end
-  end
-
-end