gluttonberg-core 2.6.4 → 3.0.0

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

@@ -0,0 +1,29 @@
+module Gluttonberg
+  module Admin
+    module AssetLibrary
+      class BaseController < Gluttonberg::Admin::BaseController
+        before_filter :find_categories, :except => [:delete, :destroy]
+        before_filter :prepare_to_edit  , :except => [:category , :show , :delete , :create , :update  ]
+        before_filter :authorize_user, :except => [:destroy , :delete]
+        before_filter :authorize_user_for_destroy , :only => [:destroy , :delete]
+
+        protected
+          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
+      end
+    end #AssetLibrary
+  end
+end

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

@@ -14,37 +14,13 @@ module Gluttonberg
           @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
+            redirect_to admin_assets_path
           else
             render :new
           end
@@ -53,7 +29,7 @@ module Gluttonberg
         def update
           if @collection.update_attributes(params[:collection])
             flash[:notice] = "The collection was successfully updated."
-            redirect_to admin_assets_url
+            redirect_to admin_assets_path
           else
             flash[:error] = "Sorry, The collection could not be updated."
             render :new
@@ -69,21 +45,19 @@ module Gluttonberg
           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
+          generic_destroy(@collection, {
+            :name => "collection",
+            :success_path => admin_assets_path,
+            :failure_path => admin_assets_path
+          })
         end
 
         private
 
-        def find_collection
-          @collection = AssetCollection.find( :first , :conditions => [" id = ? " , params[:id] ] )
-          raise ActiveRecord::RecordNotFound  if @collection.blank?
-        end # find_collection
+          def find_collection
+            @collection = AssetCollection.where(:id => params[:id]).first
+            raise ActiveRecord::RecordNotFound  if @collection.blank?
+          end # find_collection
 
       end # class
     end #asset_library

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

@@ -1,185 +1,124 @@
-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}
+module Gluttonberg
+  module Admin
+    class BaseController < Gluttonberg::BaseController
+       helper_method :current_user_session, :current_user
+       before_filter :require_user
+       before_filter :require_backend_access
+
+       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
-      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
+        # 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]
 
-    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
+          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 => "/layouts/bare"
+        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 => "/layouts/bare"
+
+        end
+
+        # Generic code for destroy action. It is done trying to avoid duplication of similar code
+        def generic_destroy(object, opts)
+          if object.destroy
+            flash[:notice] = "The #{opts[:name]} was successfully deleted."
+            redirect_to opts[:success_path]
+          else
+            flash[:error] = "There was an error deleting the #{opts[:name]}."
+            redirect_to opts[:failure_path]
+          end
+        end
+
+        # Generic code for create action. It is done trying to avoid duplication of similar code
+        def generic_create(object, opts)
+          generic_create_or_update(object, opts)
+        end
+
+        # Generic code for update action. It is done trying to avoid duplication of similar code
+        def generic_update(object, opts)
+          generic_create_or_update(object, opts)
+        end
+
+        def store_location
+          session[:return_to] = request.url
+        end
+
+        # Exception handlers
+        def not_found
+          render :layout => "bare" , :template => 'gluttonberg/admin/exceptions/not_found' , :status => 404, :handlers => [:haml], :formats => [:html]
+        end
+
+        def access_denied
+          render :layout => "bare" , :template => 'gluttonberg/admin/exceptions/not_found' , :status => 403, :handlers => [:haml], :formats => [:html]
+        end
+
+      private
+        def generic_create_or_update(object, opts)
+          message = object.new_record? ? "created" : "updated"
+          render_action = object.new_record? ? :new : :edit
+          if object.save
+            flash[:notice] = "The #{opts[:name]} was successfully #{message}."
+            redirect_to opts[:success_path]
+          else
+            render render_action
+          end
+        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 # Admin
 end

data/app/controllers/gluttonberg/admin/content/auto_save_controller.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Content
+      # this controllers saves json dump of admin forms. 
+      # javascript sends an ajax calls for saving draft version in autosave table for recovery purpose
+      class AutoSaveController < Gluttonberg::Admin::BaseController
+        before_filter :find_auto_save, :except => [:create]
+        layout nil
+        def create
+          auto_save = AutoSave.where(prepare_opts).first_or_initialize
+          auto_save.data = params[AutoSave.param_name_for(params[:model_name])].to_json
+          status = auto_save.save
+          fix_created_at_date_for_versions(auto_save)
+          render( :json => ( status ? "OK" : "Error").to_json )
+        end #create
+
+        def destroy
+          status = false
+          status = @auto_save.destroy unless @auto_save.blank?
+          render( :json => (status ? "OK" : "Error").to_json )
+        end
+
+        def retreive_changes
+          render( :json => (@auto_save.blank? ? {} : JSON.parse(@auto_save.data).to_json ) )
+        end
+
+        private
+          def prepare_opts
+            {:auto_save_able_id => params[:id], :auto_save_able_type => params[:model_name]}
+          end
+
+          def find_auto_save
+            @auto_save = AutoSave.where(prepare_opts).first
+          end
+
+          def fix_created_at_date_for_versions(auto_save)
+            if !params[:version].blank? && !auto_save.auto_save_able.blank?
+              date = nil
+              content = _find_content(auto_save)
+              if !content.blank? && content.version.to_s != params[:version].to_s
+                date = auto_save.auto_save_able.created_at
+              end
+              unless date.blank?
+                auto_save.created_at = auto_save.updated_at = date
+               auto_save.save
+              end
+            end
+          end
+
+          def _find_content(auto_save)
+            if auto_save.auto_save_able.kind_of?(Gluttonberg::PageLocalization)
+              auto_save.auto_save_able.contents.first
+            elsif Gluttonberg.constants.include?(:Blog) && Gluttonberg::Blog::Article && auto_save.auto_save_able.kind_of?(Gluttonberg::Blog::ArticleLocalization)
+              auto_save.auto_save_able
+            end
+          end
+
+      end
+    end
+  end
+end