gluttonberg-core 2.6.4 → 3.0.0

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

@@ -2,18 +2,18 @@ module Gluttonberg
   module Admin
     module Content
       class FlagController <  Gluttonberg::Admin::BaseController
-      
+
         def index
           @flags = Flag.all
         end
-        
-        def moderation 
-          @flag = Flag.find(params[:id])
+
+        def moderation
+          @flag = Flag.where(:id => params[:id]).first
           @flag.moderate(params[:moderation])
           redirect_to :back
         end
-  
+
       end
-    end  
+    end
   end
 end

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

@@ -4,6 +4,7 @@
 module Gluttonberg
   module Admin
     module Content
+      # Manage image/video gallery
       class GalleriesController < Gluttonberg::Admin::BaseController
         drag_tree GalleryImage , :route_name => :admin_gallery_move
         include ActionView::Helpers::TextHelper
@@ -20,29 +21,35 @@ module Gluttonberg
 
         def new
           @gallery = Gallery.new
+          prepare_repeaters
         end
 
         def create
+          clean_empty_repeater
           @gallery = Gallery.new(params[:gluttonberg_gallery])
           @gallery.user_id = current_user.id if @gallery.user_id.blank?
           if @gallery.save
-            save_collection_images
+            @gallery.save_collection_images(params, current_user)
             flash[:notice] = "The gallery was successfully created."
             redirect_to edit_admin_gallery_path(@gallery)
           else
-            render :edit
+            prepare_repeaters
+            render :new
           end
         end
 
         def edit
+          prepare_repeaters
         end
 
         def update
+          clean_empty_repeater
           if @gallery.update_attributes(params[:gluttonberg_gallery])
-            save_collection_images
+            @gallery.save_collection_images(params, current_user)
             flash[:notice] = "The gallery was successfully updated."
             redirect_to edit_admin_gallery_path(@gallery)
           else
+            prepare_repeaters
             flash[:error] = "Sorry, The gallery could not be updated."
             render :edit
           end
@@ -58,29 +65,11 @@ module Gluttonberg
         end
 
         def destroy
-          if @gallery.delete
-            flash[:notice] = "The gallery was successfully deleted."
-            redirect_to admin_galleries_path
-          else
-            flash[:error] = "There was an error deleting the gallery."
-            redirect_to admin_galleries_path
-          end
-        end
-
-        def remove_image
-          item =GalleryImage.find(params[:id])
-          Gluttonberg::Feed.log(current_user,item.gallery, item.gallery.title , "removed image '#{item.image.name}'")
-          item.delete
-          render :text => "{success:true}"
-        end
-
-        def add_image
-          @gallery =Gallery.find(params[:id])
-          max_position = @gallery.gallery_images.length
-          @gallery_item = @gallery.gallery_images.create(:asset_id => params[:asset_id] , :position => (max_position )  )
-          @gallery_images = @gallery.gallery_images.order("position ASC")
-          Gluttonberg::Feed.log(current_user,@gallery, @gallery.title , "added image '#{@gallery_item.image.name}'")
-          render :layout => false
+          generic_destroy(@gallery, {
+            :name => "gallery",
+            :success_path => admin_galleries_path,
+            :failure_path => admin_galleries_path
+          })
         end
 
         protected
@@ -92,28 +81,31 @@ module Gluttonberg
           end
 
           def find_gallery
-            @gallery = Gallery.find(params[:id])
+            @gallery = Gallery.where(:id => params[:id]).first
+            raise ActiveRecord::RecordNotFound if @gallery.blank?
             @gallery_images = @gallery.gallery_images.order("position ASC")
           end
 
           def authorize_user
             authorize! :manage, Gluttonberg::Gallery
+            authorize! :manage_model, "Gluttonberg::Gallery"
           end
 
           def authorize_user_for_destroy
-            authorize! :destroy, Gluttonberg::Gallery
+            authorize! :destroy, @gallery
+          end
+
+          def prepare_repeaters
+            @gallery.gallery_images.build if @gallery.gallery_images.blank?
           end
 
-          def save_collection_images
-            unless params[:collection_id].blank?
-              collection = AssetCollection.find(params[:collection_id])
-              collection_images = collection.images
-              Gluttonberg::Feed.log(current_user,@gallery, @gallery.title , "add #{pluralize(collection_images.length , 'image')} from collection '#{collection.name}'")
-              max_position = @gallery.gallery_images.length
-              collection_images.each_with_index do |image , index|
-                @gallery.gallery_images.create(:asset_id => image.id , :position => (max_position + index)  )
+          def clean_empty_repeater
+            unless params[:gluttonberg_gallery].blank? || params[:gluttonberg_gallery][:gallery_images_attributes].blank?
+              params[:gluttonberg_gallery][:gallery_images_attributes].each do |key, val|
+                if val[:asset_id].blank? && val[:caption].blank? && val[:credits].blank? && val[:link].blank? && val[:id].blank?
+                  params[:gluttonberg_gallery][:gallery_images_attributes].delete(key)
+                end
               end
-              @gallery.update_attributes(:collection_imported => true)
             end
           end
 

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

@@ -3,50 +3,22 @@ module Gluttonberg
     module Content
       class PageLocalizationsController < Gluttonberg::Admin::BaseController
         before_filter :find_localization, :exclude => [:index, :new, :create]
-        before_filter :authorize_user 
-        
+        before_filter :authorize_user
+
+        # Edit page localization content (edit page)
         def edit
-          
-          @page_localization.navigation_label = @page_localization.page.navigation_label if @page_localization.navigation_label.blank?
-          @page = @page_localization.page
-           if(!(Gluttonberg.localized? && @page.localizations &&  @page.localizations.length > 1) )
-             @page_localization.slug = @page_localization.page.slug  if @page_localization.slug.blank?
-             @page_localization.save!
-           end
-          @version = params[:version]  unless params[:version].blank?
+          fix_nav_label_and_slug
+          @version = params[:version]  
           prepare_to_edit
         end
 
         def update
-          # update localization updated_at value so that all contents have same version number.
-          @page_localization.contents.each do |content|
-            content.updated_at = Time.now
-          end
+          update_updated_at
           page_attributes = params["gluttonberg_page_localization"].delete(:page)
-          
-          if @page_localization.update_attributes(params["gluttonberg_page_localization"]) || !@page_localization.changed?            
-            
-            @page_localization.page.update_attributes(page_attributes)
-            
-            localization_detail = ""
-            if Gluttonberg.localized?
-              localization_detail = "(#{@page_localization.locale.slug})"
-            end
-            
-            if params[:commit] && params[:commit] == "Publish" || params[:commit] && params[:commit] == "Update"
-              @page_localization.page.state = "published"
-              @page_localization.page.published_at = Time.now
-              @page_localization.page.save
-              Gluttonberg::Feed.log(current_user,@page_localization.page,"#{@page_localization.page.name} #{localization_detail}" , "updated and published.")
-            else
-              @page_localization.page.state = "draft"
-              @page_localization.page.published_at = nil
-              @page_localization.page.save
-              Gluttonberg::Feed.log(current_user,@page_localization.page,"#{@page_localization.page.name} #{localization_detail}" , "saved as draft.")
-            end
-            
-            flash[:notice] = "The page was successfully updated."
-            redirect_to edit_admin_page_page_localization_path( :page_id => params[:page_id], :id =>  @page_localization.id)
+          set_page_localization_attributes(page_attributes)
+          if @page_localization.update_attributes(params["gluttonberg_page_localization"]) || !@page_localization.changed?
+            update_page_attributes(page_attributes)
+            redirect_to_edit_page
           else
             flash[:error] = "Sorry, The page could not be updated."
             prepare_to_edit
@@ -56,23 +28,84 @@ module Gluttonberg
 
         private
           def find_localization
-            @page_localization = PageLocalization.find(params[:id])
+            @page_localization = PageLocalization.where(:id => params[:id]).first
             raise ActiveRecord::RecordNotFound  unless @page_localization
+            @page = @page_localization.page
+            @page.instance_variable_set(:@current_localization, @page_localization)
           end
-          
+
           def authorize_user
             authorize! :manage, Gluttonberg::Page
+            authorize! :manage_object, @page_localization.page
           end
-          
+
           def prepare_to_edit
-            @pages  = Page.find(:all , :conditions => [ "id  != ? " , @page.id ] ) 
-            @descriptions = []
-            Gluttonberg::PageDescription.all.each do |name, desc|
-                @descriptions << [desc[:description], name]
-            end        
+            @pages  = Page.where("id != ? AND parent_id IS NULL" , @page.id).order("position asc").all
+          end
+
+          def fix_nav_label_and_slug
+            @page_localization.navigation_label = @page.navigation_label if @page_localization.navigation_label.blank?
+            if(!(Gluttonberg.localized? && @page.localizations &&  @page.localizations.length > 1) )
+              @page_localization.slug = @page_localization.page.slug  if @page_localization.slug.blank?
+              @page_localization.save!
+            end
+          end
+
+          # update localization updated_at value for all contents of a page so that all contents have same version number.
+          def update_updated_at
+            @page_localization.contents.each do |content|
+              content.updated_at = Time.now
+            end
+          end
+
+          def publish!
+            @page_localization.page.state = "published"
+            @page_localization.page.published_at = Time.now
+            @page_localization.page.save
+            Gluttonberg::Feed.log(current_user,@page_localization.page,"#{@page_localization.page.name} #{localization_detail_for_log}" , "updated and published.")
           end
-          
-      end #class  
+
+          def unpublish!
+            @page_localization.page.state = "draft"
+            @page_localization.page.published_at = nil
+            @page_localization.page.save
+            Gluttonberg::Feed.log(current_user,@page_localization.page,"#{@page_localization.page.name} #{localization_detail_for_log}" , "saved as draft.")
+          end
+
+          def localization_detail_for_log
+            localization_detail = ""
+            if Gluttonberg.localized?
+              localization_detail = "(#{@page_localization.locale.slug})"
+            end
+          end
+
+          def set_page_localization_attributes(page_attributes)
+            @page_localization.page.current_user_id = current_user.id
+            state = page_attributes.delete(:state)
+            published_at = page_attributes.delete(:published_at)
+            @page_localization.page.state = state unless state.blank?
+            @page_localization.page.published_at = published_at unless published_at.blank?
+            @page_localization.page._publish_status = page_attributes[:_publish_status]
+          end
+
+          # Page description is changed then update page structure to reflect new page description
+          def update_page_attributes(page_attributes)
+            old_description_name = @page_localization.page.description_name
+            new_description_name = page_attributes[:description_name]
+
+            if(old_description_name != new_description_name)
+              PageRepairer.change_page_description(@page_localization.page, old_description_name, new_description_name, page_attributes)
+            else
+              @page_localization.page.update_attributes(page_attributes)
+            end
+          end
+
+          def redirect_to_edit_page
+            flash[:notice] = "The page was successfully updated."
+            redirect_to edit_admin_page_page_localization_path( :page_id => params[:page_id], :id =>  @page_localization.id)+ (@page_localization.reload && @page_localization.versions && @page_localization.versions.latest.version != @page_localization.version ? "?version=#{@page_localization.versions.latest.version}" : "")
+          end
+
+      end #class
     end
-  end  
+  end
 end

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

@@ -11,22 +11,22 @@ module Gluttonberg
         record_history :@page
 
         def index
-          @pages = Page.find(:all , :conditions => { :parent_id => nil } , :order => 'position' )
+          @pages = Page.where(:parent_id => nil).includes(:user, :localizations, :collapsed_pages).order('position').all
+          @pages = @pages.find_all{|page| current_user.can_view_page(page) } 
         end
 
         def show
         end
 
         def new
-          @page = Page.new
+          @page = Page.new(:parent_id => params[:parent_id])
+          authorize! :manage_object, @page
           @page_localization = PageLocalization.new
-          prepare_to_edit
         end
 
         def delete
-          default_localization = Gluttonberg::PageLocalization.find(:first , :conditions => { :page_id => @page.id , :locale_id => Gluttonberg::Locale.first_default.id } )
           display_delete_confirmation(
-            :title      => "Delete “#{default_localization.name}” page?",
+            :title      => "Delete “#{@page.current_localization.name}” page?",
             :url        => admin_page_url(@page),
             :return_url => admin_pages_path ,
             :warning    => "Children of this page will also be deleted."
@@ -38,47 +38,49 @@ module Gluttonberg
           @page.state = "draft"
           @page.published_at = nil
           @page.user_id = current_user.id
+          @page.current_user_id = current_user.id
           if @page.save
             @page.create_default_template_file
             flash[:notice] = "The page was successfully created."
-            default_localization = Gluttonberg::PageLocalization.find(:first , :conditions => { :page_id => @page.id , :locale_id => Gluttonberg::Locale.first_default.id } )
-            redirect_to edit_admin_page_page_localization_path( :page_id => @page.id, :id => default_localization.id)
+            redirect_to edit_admin_page_page_localization_path( :page_id => @page.id, :id => @page.current_localization.id)
           else
-            prepare_to_edit
             render :new
           end
         end
 
 
         def destroy
-          if @page.destroy
-            flash[:notice] = "The page was successfully deleted."
-            redirect_to admin_pages_path
-          else
-            flash[:error] = "There was an error deleting the page."
-            redirect_to admin_pages_path
-          end
-        end
-
-        def edit_home
-          @current_home_page_id  = Page.home_page.id unless Page.home_page.blank?
-          @pages = Page.all
+          generic_destroy(@page, {
+            :name => "page",
+            :success_path => admin_pages_path,
+            :failure_path => admin_pages_path
+          })
         end
 
+        # This action is called from configuration in an ajax call for update home page
         def update_home
-          @new_home = Page.find(:first , :conditions => { :id => params[:home] })
+          @new_home = Page.where(:id => params[:home]).first
           unless @new_home.blank?
             @new_home.update_attributes(:home => true)
           else
-              @old_home = Page.find(:first , :conditions => { :home => true })
-              @old_home.update_attributes(:home => false)
+            @old_home = Page.where(:home => true).first
+            @old_home.update_attributes(:home => false)
           end
           Gluttonberg::Feed.log(current_user,@new_home,@new_home.name , "set as home")
           render :text => "Home page is changed"
         end
 
+        # Pages/posts lists for redactor
         def pages_list_for_tinymce
-          @pages = Page.published.find(:all , :conditions => "not(description_name = 'top_level_page')"  , :order => 'position' )
+          @pages = Page.published.count
+          @pages = Page.published.where("not(description_name = 'top_level_page')").order('position' )
+
+          @articles_count = 0
+          if Gluttonberg.constants.include?(:Blog)
+            @articles_count = Gluttonberg::Blog::Article.published.count
+            @blogs = Gluttonberg::Blog::Weblog.published.order("name ASC")
+          end
+
           render :layout => false
         end
 
@@ -88,24 +90,49 @@ module Gluttonberg
           @duplicated_page.user_id = current_user.id
           if @duplicated_page
             flash[:notice] = "The page was successfully duplicated."
-            default_localization = Gluttonberg::PageLocalization.find(:first , :conditions => { :page_id => @duplicated_page.id , :locale_id => Gluttonberg::Locale.first_default.id } )
-            redirect_to edit_admin_page_page_localization_path( :page_id => @duplicated_page.id, :id => default_localization.id)
+            redirect_to edit_admin_page_page_localization_path( :page_id => @duplicated_page.id, :id => @duplicated_page.current_localization.id)
           else
             flash[:error] = "There was an error duplicating the page."
             redirect_to admin_pages_path
           end
         end
 
-        private
+        # Collapse a single page in pages list
+        def collapse
+          @page = Page.find(params[:id])
+          collapse = CollapsedPage.where(:page_id => @page.id, :user_id => current_user.id).first
+          if collapse.blank?
+            CollapsedPage.create(:page_id => @page.id, :user_id => current_user.id)
+          end
+          render :json => {:status => true}
+        end
+
+        # Expand a children of single page in pages list
+        def expand
+          CollapsedPage.delete_all(:page_id => params[:id], :user_id => current_user.id)
+          render :json => {:status => true}
+        end
 
-        def prepare_to_edit
-          @pages  = params[:id] ? Page.find(:all , :conditions => [ "id  != ? " , params[:id] ] ) : Page.all
-          @descriptions = []
-          Gluttonberg::PageDescription.all.each do |name, desc|
-              @descriptions << [desc[:description], name]
+        def collapse_all
+          @pages = Page.all
+          @pages.each do |page|
+            if page.children.count > 0
+              collapse = CollapsedPage.where(:page_id => page.id, :user_id => current_user.id).first
+              if collapse.blank?
+                CollapsedPage.create(:page_id => page.id, :user_id => current_user.id)
+              end
+            end
           end
+          render :json => {:status => true}
+        end
+
+        def expand_all
+          CollapsedPage.delete_all(:user_id => current_user.id)
+          render :json => {:status => true}
         end
 
+        private
+
         def find_page
           @page = Page.find( params[:id])
           raise ActiveRecord::RecordNotFound unless @page