gluttonberg-core 2.5

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

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Content    
+      class ArticlesController < Gluttonberg::Admin::BaseController
+        
+        before_filter :find_blog , :except => [:create]
+        before_filter :find_article, :only => [:show, :edit, :update, :delete, :destroy , :duplicate]
+        before_filter :authorize_user , :except => [:destroy , :delete]  
+        before_filter :authorize_user_for_destroy , :only => [:destroy , :delete]  
+        record_history :@article , :title
+        
+        def index
+          conditions = {:blog_id => @blog.id}
+          conditions[:user_id] = current_user.id unless current_user.super_admin?
+          @articles = Article.where( conditions).paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page])
+        end
+        
+        
+        def show
+          @comment = Comment.new
+        end
+        
+        def new
+          @article = Article.new
+          @article_localization = ArticleLocalization.new(:article => @article , :locale_id => Locale.first_default.id)
+          @authors = User.all
+        end
+        
+        def create
+          params[:gluttonberg_article_localization][:article][:name] = params[:gluttonberg_article_localization][:title]
+          article_attributes = params["gluttonberg_article_localization"].delete(:article)
+          @article = Article.new(article_attributes)
+          if @article.save
+            Locale.all.each do |locale|
+              @article_localization = ArticleLocalization.create(params[:gluttonberg_article_localization].merge(:locale_id => locale.id , :article_id => @article.id))
+            end
+            flash[:notice] = "The article was successfully created."
+            redirect_to edit_admin_blog_article_path(@article.blog, @article)
+          else
+            render :edit
+          end
+        end
+        
+        def edit
+          @authors = User.all
+          unless params[:version].blank?
+            @version = params[:version]
+            @article.revert_to(@version)
+          end
+        end
+        
+        def update
+          article_attributes = params["gluttonberg_article_localization"].delete(:article)
+          if @article_localization.update_attributes(params[:gluttonberg_article_localization])
+            article = @article_localization.article
+            article.current_slug = article.slug
+            article.assign_attributes(article_attributes)
+            article.previous_slug = article.current_slug if article.slug_changed?
+            article.save
+            
+            localization_detail = ""
+            if Gluttonberg.localized?
+              localization_detail = " (#{@article_localization.locale.slug}) "
+            end
+            if Gluttonberg.localized?
+              Gluttonberg::Feed.log(current_user,@article_localization,"#{@article_localization.title}#{localization_detail}" , "updated")
+            end
+
+            flash[:notice] = "The article was successfully updated."
+            redirect_to admin_blog_articles_path(@blog)
+          else
+            flash[:error] = "Sorry, The article could not be updated."
+            render :edit
+          end
+        end
+        
+        def delete
+          display_delete_confirmation(
+            :title      => "Delete Article '#{@article.title}'?",
+            :url        => admin_blog_article_path(@blog, @article),
+            :return_url => admin_blog_articles_path(@blog), 
+            :warning    => ""
+          )
+        end
+        
+        def destroy
+          title = @article.current_localization.title
+          if @article.destroy
+            flash[:notice] = "The article was successfully deleted."
+            redirect_to admin_blog_articles_path(@blog)
+          else
+            flash[:error] = "There was an error deleting the Article."
+            redirect_to admin_blog_articles_path(@blog)
+          end
+        end
+
+        def duplicate
+          @duplicated_article = @article.duplicate
+          @duplicated_article.user_id = current_user.id
+          if @duplicated_article
+            flash[:notice] = "The article was successfully duplicated."
+            redirect_to edit_admin_blog_article_path(@blog, @duplicated_article)
+          else
+            flash[:error] = "There was an error duplicating the article."
+            redirect_to admin_blog_articles_path(@blog)
+          end
+        end
+        
+        protected
+        
+          def find_blog
+            @blog = Blog.find(params[:blog_id])
+          end
+          
+          def find_article
+            if params[:localization_id].blank?
+              conditions = { :article_id => params[:id] , :locale_id => Locale.first_default.id}
+              #conditions[:user_id] = current_user.id unless current_user.super_admin?
+              @article_localization = ArticleLocalization.find(:first , :conditions => conditions)
+            else
+              @article_localization = ArticleLocalization.find(params[:localization_id])
+            end
+            @article = Article.find(:first , :conditions => {:id => params[:id]})
+          end
+          
+          def authorize_user
+            authorize! :manage, Gluttonberg::Article
+          end
+
+          def authorize_user_for_destroy
+            authorize! :destroy, Gluttonberg::Article
+          end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Content    
+      class BlogsController < Gluttonberg::Admin::BaseController
+        
+        before_filter :find_blog, :only => [:edit, :update, :delete, :destroy]
+        before_filter :require_super_admin_user , :except => [:index]
+        before_filter :authorize_user , :except => [:destroy , :delete]  
+        before_filter :authorize_user_for_destroy , :only => [:destroy , :delete]
+        record_history :@blog
+
+        def index
+          @blogs = Blog.paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page])
+          if @blogs && @blogs.size == 1
+            redirect_to admin_blog_articles_path(@blogs.first)
+          end
+        end
+        
+        def show
+          @blog = Blog.find(params[:id])
+          if @blog
+            redirect_to admin_blog_articles_path(@blog)
+          else
+            redirect_to admin_blog_path
+          end
+        end
+        
+        def new
+          @blog = Blog.new
+        end
+        
+        def create
+          @blog = Blog.new(params[:gluttonberg_blog])
+          if @blog.save
+            flash[:notice] = "The blog was successfully created."
+            redirect_to admin_blogs_path
+          else
+            render :edit
+          end
+        end
+        
+        def edit
+          unless params[:version].blank?
+            @version = params[:version]  
+            @blog.revert_to(@version)
+          end
+        end
+        
+        def update
+          @blog.current_slug = @blog.slug
+          @blog.assign_attributes(params[:gluttonberg_blog])
+          @blog.previous_slug = @blog.current_slug if @blog.slug_changed?
+          if @blog.save
+            flash[:notice] = "The blog was successfully updated."
+            redirect_to admin_blogs_path
+          else
+            flash[:error] = "Sorry, The blog could not be updated."
+            render :edit
+          end
+        end
+                
+        def delete
+          display_delete_confirmation(
+            :title      => "Delete Blog '#{@blog.name}'?",
+            :url        => admin_blog_path(@blog),
+            :return_url => admin_blogs_path, 
+            :warning    => "This will delete all the articles that belong to this blog"
+          )
+        end
+        
+        def destroy
+          if @blog.delete
+            flash[:notice] = "The blog was successfully deleted."
+            redirect_to admin_blogs_path
+          else
+            flash[:error] = "There was an error deleting the blog."
+            redirect_to admin_blogs_path
+          end
+        end
+        
+                
+        protected
+        
+          def find_blog
+            @blog = Blog.find(params[:id])
+          end
+          
+          def authorize_user
+            authorize! :manage, Gluttonberg::Blog
+          end
+
+          def authorize_user_for_destroy
+            authorize! :destroy, Gluttonberg::Blog
+          end
+          
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Content    
+      class CommentsController < Gluttonberg::Admin::BaseController
+        include ActionView::Helpers::TextHelper
+        
+        before_filter :find_blog
+        before_filter :find_article ,  :except => [:index]
+        before_filter :authorize_user ,  :except => [:moderation]
+        
+        
+        def index
+          find_article([:comments])
+          @comments = @article.comments.paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page])
+        end
+        
+        def delete
+          @comment = Comment.find(params[:id], :conditions => {:commentable_type => "Gluttonberg::Article", :commentable_id => @article.id})
+          display_delete_confirmation(
+            :title      => "Delete Comment ?",
+            :url        => admin_blog_article_comment_path(@blog, @article, @comment),
+            :return_url => admin_blog_article_comments_path(@blog, @article), 
+            :warning    => ""
+          )
+        end
+        
+        def moderation 
+          authorize_user_for_moderation
+          @comment = Comment.find(params[:id], :conditions => {:commentable_type => "Gluttonberg::Article", :commentable_id => @article.id})
+          @comment.moderate(params[:moderation])
+          Gluttonberg::Feed.log(current_user,@comment, truncate(@comment.body, :length => 100) , params[:moderation])
+          redirect_to admin_blog_article_comments_path(@blog, @article)
+        end
+        
+        def destroy
+          @comment = Comment.find(params[:id])
+          if @comment.delete
+            flash[:notice] = "The comment was successfully deleted."
+            Gluttonberg::Feed.log(current_user,@comment, truncate(@comment.body, :length => 100) , "deleted")
+            redirect_to admin_blog_article_comments_path(@blog, @article)
+          else
+            flash[:error] = "There was an error deleting the comment."
+            redirect_to admin_blog_article_comments_path(@blog, @article)
+          end
+        end
+        
+        protected
+        
+          def find_blog
+            @blog = Blog.find(params[:blog_id])
+            raise ActiveRecord::RecordNotFound unless @blog
+          end
+          
+          def find_article(include_model=[])
+            conditions = { :id => params[:article_id] }
+            conditions[:user_id] = current_user.id unless current_user.super_admin?
+            @article = Article.find(:first , :conditions => conditions , :include => include_model )
+            raise ActiveRecord::RecordNotFound unless @article
+          end
+        
+          def authorize_user
+            authorize! :manage, Gluttonberg::Comment
+          end
+          
+          def authorize_user_for_moderation
+            authorize! :moderate, Gluttonberg::Comment
+          end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,123 @@
+
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Content
+      class GalleriesController < Gluttonberg::Admin::BaseController
+        drag_tree GalleryImage , :route_name => :admin_gallery_move
+        include ActionView::Helpers::TextHelper
+
+        before_filter :is_gallery_enabled
+        before_filter :find_gallery, :only => [:edit, :update, :delete, :destroy]
+        before_filter :authorize_user , :except => [:destroy , :delete]
+        before_filter :authorize_user_for_destroy , :only => [:destroy , :delete]
+        record_history :@gallery , :title
+
+        def index
+          @galleries = Gallery.paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page])
+        end
+
+        def new
+          @gallery = Gallery.new
+        end
+
+        def create
+          @gallery = Gallery.new(params[:gluttonberg_gallery])
+          @gallery.user_id = current_user.id if @gallery.user_id.blank?
+          if @gallery.save
+            save_collection_images
+            flash[:notice] = "The gallery was successfully created."
+            redirect_to edit_admin_gallery_path(@gallery)
+          else
+            render :edit
+          end
+        end
+
+        def edit
+        end
+
+        def update
+          if @gallery.update_attributes(params[:gluttonberg_gallery])
+            save_collection_images
+            flash[:notice] = "The gallery was successfully updated."
+            redirect_to edit_admin_gallery_path(@gallery)
+          else
+            flash[:error] = "Sorry, The gallery could not be updated."
+            render :edit
+          end
+        end
+
+        def delete
+          display_delete_confirmation(
+            :title      => "Delete gallery '#{@gallery.name}'?",
+            :url        => admin_gallery_path(@gallery),
+            :return_url => admin_galleries_path,
+            :warning    => ""
+          )
+        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
+        end
+
+        protected
+
+          def is_gallery_enabled
+            unless Rails.configuration.enable_gallery == true
+              raise ActiveRecord::RecordNotFound
+            end
+          end
+
+          def find_gallery
+            @gallery = Gallery.find(params[:id])
+            @gallery_images = @gallery.gallery_images.order("position ASC")
+          end
+
+          def authorize_user
+            authorize! :manage, Gluttonberg::Gallery
+          end
+
+          def authorize_user_for_destroy
+            authorize! :destroy, Gluttonberg::Gallery
+          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)  )
+              end
+              @gallery.update_attributes(:collection_imported => true)
+            end
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Gluttonberg
+  module Admin
+    module Content
+      class MainController < Gluttonberg::Admin::BaseController
+        
+        def index
+          redirect_to admin_pages_path
+        end
+      
+      end #class
+    end #content
+  end #admin
+end #GB

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

@@ -0,0 +1,78 @@
+module Gluttonberg
+  module Admin
+    module Content
+      class PageLocalizationsController < Gluttonberg::Admin::BaseController
+        before_filter :find_localization, :exclude => [:index, :new, :create]
+        before_filter :authorize_user 
+        
+        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?
+          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
+          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)
+          else
+            flash[:error] = "Sorry, The page could not be updated."
+            prepare_to_edit
+            render :edit
+          end
+        end
+
+        private
+          def find_localization
+            @page_localization = PageLocalization.find(params[:id])
+            raise ActiveRecord::RecordNotFound  unless @page_localization
+          end
+          
+          def authorize_user
+            authorize! :manage, Gluttonberg::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        
+          end
+          
+      end #class  
+    end
+  end  
+end

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

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Content
+      class PagesController < Gluttonberg::Admin::BaseController
+        drag_tree Page , :route_name => :admin_page_move
+        before_filter :find_page, :only => [:show, :edit, :delete, :update, :destroy]
+        before_filter :authorize_user , :except => [:destroy , :delete]
+        before_filter :authorize_user_for_destroy , :only => [:destroy , :delete]
+        record_history :@page
+
+        def index
+          @pages = Page.find(:all , :conditions => { :parent_id => nil } , :order => 'position' )
+        end
+
+        def show
+        end
+
+        def new
+          @page = Page.new
+          @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?",
+            :url        => admin_page_url(@page),
+            :return_url => admin_pages_path ,
+            :warning    => "Children of this page will also be deleted."
+          )
+        end
+
+        def create
+          @page = Page.new(params["gluttonberg_page"])
+          @page.state = "draft"
+          @page.published_at = nil
+          @page.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)
+          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
+        end
+
+        def update_home
+          @new_home = Page.find(:first , :conditions => { :id => params[:home] })
+          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)
+          end
+          Gluttonberg::Feed.log(current_user,@new_home,@new_home.name , "set as home")
+          render :text => "Home page is changed"
+        end
+
+        def pages_list_for_tinymce
+          @pages = Page.published.find(:all , :conditions => "not(description_name = 'top_level_page')"  , :order => 'position' )
+          render :layout => false
+        end
+
+        def duplicate
+          @page = Page.find(params[:id])
+          @duplicated_page = @page.duplicate
+          @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)
+          else
+            flash[:error] = "There was an error duplicating the page."
+            redirect_to admin_pages_path
+          end
+        end
+
+        private
+
+        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]
+          end
+        end
+
+        def find_page
+          @page = Page.find( params[:id])
+          raise ActiveRecord::RecordNotFound unless @page
+        end
+
+        def authorize_user
+          authorize! :manage, Gluttonberg::Page
+        end
+
+        def authorize_user_for_destroy
+          authorize! :destroy, Gluttonberg::Page
+        end
+
+      end
+    end #content
+  end #admin
+end  #gluttonberg

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

@@ -0,0 +1,15 @@
+module Gluttonberg
+  module Admin
+    class HelpController <  Gluttonberg::Admin::BaseController
+      layout "help"
+    
+      def show
+        template = Help.path_to_template(:controller => params[:module_and_controller], :page => params[:page])
+        opts = {:template => template}
+        opts[:layout] = "ajax" if request.xhr?
+        render(opts)
+      end
+      
+    end
+  end  
+end