gluttonberg-core 2.6.4 → 3.0.0

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

@@ -1,101 +0,0 @@
-# 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

@@ -1,130 +0,0 @@
-# encoding: utf-8
-
-module Gluttonberg
-  module Admin
-    module Content
-      class CommentsController < Gluttonberg::Admin::BaseController
-        include ActionView::Helpers::TextHelper
-
-        before_filter :find_blog , :except => [:all , :approved, :rejected , :pending , :spam , :moderation , :delete , :destroy , :spam_detection_for_all_pending , :block_comment_author]
-        before_filter :find_article ,  :except => [:index, :all , :approved , :rejected , :pending , :spam , :moderation , :delete , :destroy , :spam_detection_for_all_pending , :block_comment_author]
-        before_filter :authorize_user ,  :except => [:moderation]
-
-
-        def index
-          find_article([:comments])
-          @comments = @article.comments.order("created_at DESC").paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page] , :order => "created_at DESC")
-        end
-
-        def delete
-          @comment = Comment.find(params[:id])
-          display_delete_confirmation(
-            :title      => "Delete Comment ?",
-            :url        => admin_comment_destroy_path(@comment),
-            :return_url => :back,
-            :warning    => ""
-          )
-        end
-
-        def moderation
-          authorize_user_for_moderation
-          @comment = Comment.find(params[:id])
-          @comment.moderate(params[:moderation])
-          Gluttonberg::Feed.log(current_user,@comment, truncate(@comment.body, :length => 100) , params[:moderation])
-          redirect_to :back
-        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_pending_comments_path()
-          else
-            flash[:error] = "There was an error deleting the comment."
-            redirect_to admin_pending_comments_path()
-          end
-        end
-
-
-        def pending
-          @comments = Comment.all_pending.order("created_at DESC").paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page] , :order => "created_at DESC")
-          render :template => "/gluttonberg/admin/content/comments/index"
-        end
-
-        def approved
-          @comments = Comment.all_approved.order("created_at DESC").paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page] , :order => "created_at DESC")
-          render :template => "/gluttonberg/admin/content/comments/index"
-        end
-
-        def rejected
-          @comments = Comment.all_rejected.order("created_at DESC").paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page] , :order => "created_at DESC")
-          render :template => "/gluttonberg/admin/content/comments/index"
-        end
-
-        def spam
-          @comments = Comment.all_spam.order("created_at DESC").paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page] , :order => "created_at DESC")
-          render :template => "/gluttonberg/admin/content/comments/index"
-        end
-
-        def spam_detection_for_all_pending
-          Comment.spam_detection_for_all
-          redirect_to admin_pending_comments_path
-        end
-
-        def block_comment_author
-          @comment = Comment.find(params[:id])
-
-          author_string = ""
-          unless @comment.author_name.blank? || @comment.author_name == "NULL" || @comment.author_name.length < 3
-            author_string += @comment.author_name
-          end
-          unless @comment.author_email.blank? || @comment.author_email == "NULL" || @comment.author_email.length < 3
-            author_string += ", " unless author_string.blank?
-            author_string += @comment.author_email
-          end
-          unless @comment.author_website.blank? || @comment.author_website == "NULL" || @comment.author_website.length < 3
-            author_string += ", " unless author_string.blank?
-            author_string += @comment.author_website
-          end
-          unless author_string.blank?
-            author_string
-            gb_blacklist_settings = Gluttonberg::Setting.get_setting("comment_blacklist")
-            if gb_blacklist_settings.blank?
-              gb_blacklist_settings = author_string
-            else
-              gb_blacklist_settings = gb_blacklist_settings + ", " + author_string
-            end
-            Gluttonberg::Setting.update_settings("comment_blacklist" => gb_blacklist_settings)
-            Comment.spam_detection_for_all
-          end
-          redirect_to admin_pending_comments_path
-        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/main_controller.rb

@@ -1,13 +0,0 @@
-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/help_controller.rb

@@ -1,15 +0,0 @@
-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

data/app/controllers/gluttonberg/admin/settings/generic_settings_controller.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-
-module Gluttonberg
-  module  Admin
-    module Settings
-      class GenericSettingsController < Gluttonberg::Admin::BaseController
-        before_filter :find_setting, :only => [:delete, :edit, :update, :destroy]
-        before_filter :authorize_user
-        before_filter :authorize_user_for_create_or_destroy, :only => [:delete, :new, :create, :destroy]
-        record_history :@setting
-        
-        def index
-          @settings = Setting.find(:all , :order => "row asc")
-          @current_home_page_id  = Page.home_page.id unless Page.home_page.blank?
-          @pages = Page.all
-        end
-              
-        def new
-          @setting = Setting.new
-        end
-    
-        def edit
-        end
-    
-        def create
-          @setting = Setting.new(params["gluttonberg_setting"])
-          count = Setting.all.length
-          @setting.row = count + 1
-          if @setting.save
-            flash[:notice] = "The article was successfully created."
-            redirect_to admin_generic_settings_path
-          else
-            render :new
-          end
-        end
-    
-        def update
-          if params.has_key? "gluttonberg/setting"
-            params[:gluttonberg_setting] = params["gluttonberg/setting"]
-          end  
-          if @setting.update_attributes(params[:gluttonberg_setting])
-            if request.xhr?
-              render :text => @setting.value
-            else
-              flash[:notice] = "The setting was successfully updated."
-              format.html redirect_to admin_generic_settings_path 
-            end            
-          else
-            flash[:error] = "Sorry, The setting could not be updated."
-            render :edit
-          end
-        end
-      
-        
-        def delete
-          display_delete_confirmation(
-            :title      => "Delete “#{@setting.name}” setting?",
-            :url        => admin_generic_setting_path(@setting),
-            :return_url => admin_generic_settings_path 
-          )
-        end
-
-        def destroy
-          if @setting.destroy
-            flash[:notice] = "The setting was successfully deleted."
-            redirect_to admin_generic_settings_path
-          else
-            flash[:error] = "There was an error deleting the setting."
-            redirect_to admin_generic_settings_path
-          end
-        end
-    
-        private
-
-        def find_setting
-          @setting = Setting.find(params[:id]) 
-          raise ActiveRecord::RecordNotFound  unless @setting
-        end
-        
-        def authorize_user
-          authorize! :manage, Gluttonberg::Setting
-        end
-        def authorize_user_for_create_or_destroy
-          authorize! :create_or_destroy, Gluttonberg::Setting
-        end
-    
-      end # GenericSettings
-    end # Settings
-  end #admin  
-end # Gluttonberg

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

@@ -1,11 +0,0 @@
-
-module Gluttonberg
-  module Admin
-    module Settings  
-          class MainController < Gluttonberg::Admin::BaseController
-            def index
-            end
-          end
-      end    
-  end
-end

data/app/controllers/gluttonberg/public/articles_controller.rb

@@ -1,79 +0,0 @@
-module Gluttonberg
-  module Public
-    class ArticlesController <   Gluttonberg::Public::BaseController
-
-      def index
-        @blog = Gluttonberg::Blog.published.first(:conditions => {:slug => params[:blog_id]}, :include => [:articles])
-        raise ActiveRecord::RecordNotFound.new if @blog.blank?
-        @articles = @blog.articles.published
-
-         respond_to do |format|
-           format.html
-           format.rss { render :layout => false }
-        end
-      end
-
-      def show
-
-        @blog = Gluttonberg::Blog.published.first(:conditions => {:slug => params[:blog_id]})
-
-        if @blog.blank?
-          @blog = Gluttonberg::Blog.published.first(:conditions => {:previous_slug => params[:blog_id]})
-
-          unless @blog.blank?
-             redirect_to blog_article_path(:blog_id => @blog.slug , :id => params[:id]) , :status => 301
-             return
-          end
-        end
-
-        raise ActiveRecord::RecordNotFound.new if @blog.blank?
-        @article = Gluttonberg::Article.published.first(:conditions => {:slug => params[:id], :blog_id => @blog.id})
-        if @article.blank?
-          @article = Gluttonberg::Article.published.first(:conditions => {:previous_slug => params[:id], :blog_id => @blog.id})
-          unless @article.blank?
-             redirect_to blog_article_path(:blog_id => @blog.slug , :id => @article.slug) , :status => 301
-             return
-          end
-        end
-
-        raise ActiveRecord::RecordNotFound.new if @article.blank?
-        @article.load_localization(env['gluttonberg.locale'])
-        @comments = @article.comments.where(:approved => true)
-        @comment = Comment.new(:subscribe_to_comments => true)
-        respond_to do |format|
-          format.html
-        end
-      end
-
-      def tag
-        @articles = Article.tagged_with(params[:tag]).includes(:blog).published
-        @tags = Gluttonberg::Article.published.tag_counts_on(:tag)
-        respond_to do |format|
-          format.html
-        end
-      end
-
-      def unsubscribe
-        @subscription = CommentSubscription.find(:first , :conditions => {:reference_hash => params[:reference] })
-        unless @subscription.blank?
-          @subscription.destroy
-          flash[:notice] = "You are successfully unsubscribe from comments of \"#{@subscription.article.title}\""
-          redirect_to blog_article_url(@subscription.article.blog.slug, @subscription.article.slug)
-        end
-        respond_to do |format|
-          format.html
-        end
-      end
-
-      def preview
-        @blog = Gluttonberg::Blog.first(:conditions => {:slug => params[:blog_id]})
-        raise ActiveRecord::RecordNotFound.new if @blog.blank?
-        @article = Gluttonberg::Article.first(:conditions => {:slug => params[:article_id], :blog_id => @blog.id})
-        @article.load_localization(Locale.where(params[:locale_id]).first)
-        raise ActiveRecord::RecordNotFound.new if @article.blank?
-        render :show
-      end
-
-    end
-  end
-end