gluttonberg-core 2.5

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

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

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

@@ -0,0 +1,365 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module AssetLibrary
+      class AssetsController < Gluttonberg::Admin::BaseController
+        before_filter :find_categories, :except => [:delete, :destroy]
+        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]
+        record_history :@asset
+        include Gluttonberg::ApplicationHelper
+
+        # home page of asset library
+        def index
+
+        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")
+            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 {
+
+              }
+            end
+          end
+
+        end
+
+        # if filter param is provided then it will only show filtered type
+        def browser
+          # Get the latest assets
+          @assets = Asset.order("created_at DESC").includes(:asset_type)
+
+          @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
+
+        # 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
+          puts "----#{Gluttonberg::Setting.get_setting("number_of_per_page_items")}   #{page}"
+          @assets = @assets.paginate( :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items") , :page => page ).order(get_order)
+        end
+
+
+        def show
+        end
+
+        def destroy_assets_in_bulk
+          @assets = Asset.delete_all(:id => params[:asset_ids].split(","))
+          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
+        end
+
+        def edit
+        end
+
+        def crop
+          @image_type = params[:image_type]
+          @image_type = @image_type.to_sym unless @image_type.blank?
+        end
+
+        def save_crop
+          @asset.generate_cropped_image(params[:x] , params[:y] , params[:w] , params[:h] , params[:image_size])
+          flash[:notice] = "New cropped image was successfully created"
+          redirect_to :back
+        end
+
+        # delete asset
+        def delete
+          return_url = "/admin/browse/all/page/1"
+          return_url =  request.referrer unless request.referrer.blank?
+          display_delete_confirmation(
+            :title      => "Delete “#{@asset.name}” asset?",
+            :url        => admin_asset_path(@asset),
+            :return_url => return_url
+          )
+        end
+
+        # create individual asset
+        def create
+          # 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 @asset.save
+            flash[:notice] = "The asset was successfully created."
+            redirect_to(admin_asset_url(@asset))
+          else
+            prepare_to_edit
+            render :new
+          end
+        end
+
+        # update asset
+        def update
+          # process new asset_collection and merge into existing collections
+          process_new_collection_and_merge(params)
+
+          if @asset.update_attributes(params[:asset])
+            flash[:notice] = "The asset was successfully updated."
+            redirect_to(admin_asset_url(@asset))
+          else
+            prepare_to_edit
+            flash[:error] = "Sorry, The asset could not be updated."
+            render :edit
+          end
+        end
+
+        # destroy an indivdual asset
+        def destroy
+          if @asset.destroy
+            flash[:notice] = "The asset was successfully deleted."
+          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]))
+            redirect_to params[:return_url]
+          else
+            redirect_to "/admin/browse/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
+          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
+          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
+
+
+            # 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
+
+
+      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

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

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module AssetLibrary
+      class CollectionsController < Gluttonberg::Admin::BaseController
+        before_filter :find_collection  , :only => [:delete , :edit  , :show , :update , :destroy]
+
+        def index
+          @collections = AssetCollection.all
+        end
+
+        def new
+          @collection = AssetCollection.new
+        end
+
+        def edit
+        end
+
+        # if u pass filter param then it will bring filtered assets inside collection
+        def show
+          @category_filter = ( params[:filter].blank? ? "all" : params[:filter] )
+          opts = {
+              :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items") ,
+              :page => params[:page]
+          }
+
+          params[:order_type] = (params[:order_type].blank? ? "desc" : params[:order_type])
+
+          @assets = @collection.assets
+
+          if @category_filter != "all"
+            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
+
+          @assets = @assets.paginate( opts ).order(get_order)
+        end
+
+
+        def create
+          @collection = AssetCollection.new(params[:collection])
+          @collection.user_id = current_user.id
+          if @collection.save
+            flash[:notice] = "The collection was successfully created."
+            # library home page
+            redirect_to admin_assets_url
+          else
+            render :new
+          end
+        end
+
+        def update
+          if @collection.update_attributes(params[:collection])
+            flash[:notice] = "The collection was successfully updated."
+            redirect_to admin_assets_url
+          else
+            flash[:error] = "Sorry, The collection could not be updated."
+            render :new
+          end
+        end
+
+         def delete
+            display_delete_confirmation(
+              :title      => "Delete “#{@collection.name}” asset collection?",
+              :url        => admin_collection_path(@collection),
+              :return_url => admin_collections_path
+            )
+          end
+
+        def destroy
+          if @collection.destroy
+            flash[:notice] = "The collection was successfully deleted."
+            redirect_to admin_assets_url
+          else
+            flash[:error] = "There was an error deleting the collection."
+            redirect_to admin_assets_url
+          end
+        end
+
+        private
+
+        def find_collection
+          @collection = AssetCollection.find( :first , :conditions => [" id = ? " , params[:id] ] )
+          raise ActiveRecord::RecordNotFound  if @collection.blank?
+        end # find_collection
+
+      end # class
+    end #asset_library
+  end #admin
+end #gb

data/app/controllers/gluttonberg/admin/base_controller.rb

@@ -0,0 +1,185 @@
+class Gluttonberg::Admin::BaseController < ActionController::Base
+   helper_method :current_user_session, :current_user
+   before_filter :require_user
+   before_filter :require_backend_access
+
+   
+   if Rails.env == "production"
+     rescue_from ActionView::MissingTemplate, :with => :not_found
+     rescue_from ActiveRecord::RecordNotFound, :with => :not_found
+     rescue_from ActionController::RoutingError, :with => :not_found
+     rescue_from CanCan::AccessDenied, :with => :access_denied
+   end   
+   
+   layout 'gluttonberg'
+
+   unloadable
+  
+  
+  protected 
+
+
+
+    # this method is used by sorter on asset listing by category and by collection
+    def get_order
+      order_type = params[:order_type].blank? ? "desc" : params[:order_type]
+      case params[:order]
+      when 'asset_name'
+        "gb_assets.name #{order_type}"
+      when 'first_name'
+        "first_name #{order_type}"
+      when 'email'
+        "email #{order_type}" 
+      when 'role'
+        "role #{order_type}"   
+      when 'member_groups'
+        "name #{order_type}"  
+      when 'name'
+        "name #{order_type}"  
+      when 'date-updated'
+        "updated_at #{order_type}"
+      when 'created_at'
+        "created_at #{order_type}"  
+      else
+        "created_at #{order_type}"
+      end
+    end
+    
+    
+    # This is to be called from within a controller — i.e. the delete action — 
+    # and it will display a dialog which allows users to either confirm 
+    # deleting a record or cancelling the action.
+    def display_delete_confirmation(opts)
+      @options = opts      
+      @do_not_delete = (@options[:do_not_delete].blank?)? false : @options[:do_not_delete]
+      
+      unless @do_not_delete
+        @options[:title]    ||= "Delete Record?"
+        @options[:message]  ||= "If you delete this record, it will be gone permanently. There is no undo."
+      else
+        @options[:title]    = "Sorry you cannot delete this record!"
+        @options[:message]  ||= "It is been used by some other records."
+      end  
+      render :template => "gluttonberg/admin/shared/delete", :layout => false
+    end
+    
+    # This is to be called from within a controller — i.e. the publish/unpublish action — 
+    # and it will display a dialog which allows users to either confirm 
+    # publish/unpublish a record or cancelling the action.
+    def display_generic_confirmation(name , opts)
+      @options = opts
+      @do_not_do = (@options[:do_not_do].blank?)? false : @options[:do_not_do]
+      @name = name
+      
+      unless @do_not_do
+        @options[:title]    ||= "#{@name.capitalize} Record?"
+        @options[:message]  ||= "If you #{@name.downcase} this record, it will be #{@name}"
+      else
+        @options[:title]    = "Sorry you cannot #{@name.capitalize} this record!"
+        @options[:message]  ||= "It's parent record is not #{@name.capitalize}."
+      end  
+      render :template => "shared/generic", :layout => false
+      
+    end
+    
+    # A helper for finding shortcutting the steps in finding a model ensuring
+    # it has a localization and raising a NotFound if it’s missing.
+    # TODO Fixme
+    def with_localization(model, id)
+      result = model.first_with_localization(localization_ids.merge(:id => id))
+      raise NotFound unless result
+      result.ensure_localization!
+      result
+    end
+    
+    # Returns a hash with the locale and dialect ids extracted from the params
+    # or where they're missing, it will grab the defaults.
+    # TODO Do we need it anymore?
+    def localization_ids
+      @localization_opts ||= begin
+        if params[:localization]
+          ids = params[:localization].split("-")
+          {:locale => ids[0]}
+        else
+          locale = Gluttonberg::Locale.find(:first , :conditions => { :default => true })
+          # Inject the ids into the params so our form fields behave
+          params[:localization] = "#{locale.id}"
+          {:locale => locale.id}
+        end
+      end
+    end
+    
+    # Below is all the required methods for authentication
+    def current_user_session
+      return @current_user_session if defined?(@current_user_session)
+      @current_user_session = UserSession.find
+    end
+
+    def current_user
+      return @current_user if defined?(@current_user)
+      @current_user = current_user_session && current_user_session.record
+    end
+
+    def require_user
+      unless current_user
+        store_location
+        flash[:notice] = "You must be logged in to access this page"
+        redirect_to admin_login_url
+        return false
+      end
+      true
+    end
+    
+    
+    
+    def require_backend_access
+      return false unless require_user
+      unless current_user.have_backend_access?
+        store_location
+        flash[:notice] = "You dont have privilege to access this page"
+        redirect_to admin_login_url
+        return false
+      end
+    end
+    
+    
+    def require_super_admin_user
+      return false unless require_user
+      
+      unless current_user.super_admin?
+        store_location
+        flash[:notice] = "You dont have privilege to access this page"
+        redirect_to admin_login_url
+        return false
+      end
+    end
+    
+    def store_location
+      session[:return_to] = request.url
+    end
+
+    def redirect_back_or_default(default)
+      redirect_to(session[:return_to] || default)
+      session[:return_to] = nil
+    end
+    
+    
+    # Exception handlers
+    def not_found
+        render :layout => "bare" , :template => 'gluttonberg/admin/exceptions/not_found.html.haml' , :status => 404
+    end
+    
+    def access_denied
+      render :layout => "bare" , :template => 'gluttonberg/admin/exceptions/access_denied.html.haml'
+    end
+
+    # handle NotAcceptable exceptions (406)
+    def not_acceptable
+      render :layout => "bare" , :template => 'gluttonberg/admin/exceptions/not_acceptable.html.haml'
+    end
+    def internal_server_error
+      render :layout => "bare" , :template => 'gluttonberg/admin/exceptions/internal_server_error.html.haml'
+    end
+    
+  
+end