gluttonberg-blog 1.0.0

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

@@ -0,0 +1,88 @@
+module Gluttonberg
+  module Public
+    module Blog
+      class ArticlesController <   Gluttonberg::Public::BaseController
+        before_filter :find_blog, :only => [:index, :show, :preview]
+
+        def index
+          @articles = @blog.articles.published.includes(:localizations)
+          respond_to do |format|
+            format.html
+            format.rss { render :layout => false }
+          end
+        end
+
+        def show
+          find_article
+          return if redirect_if_previous_path
+          load_correct_version_and_localization
+
+          @comments = @article.comments.where(:approved => true)
+          @comment = Gluttonberg::Blog::Comment.new(:subscribe_to_comments => true)
+          respond_to do |format|
+            format.html
+          end
+        end
+
+        def tag
+          @articles = Gluttonberg::Blog::Article.tagged_with(params[:tag]).includes(:blog).published
+          @tags = Gluttonberg::Blog::Article.published.tag_counts_on(:tag)
+          respond_to do |format|
+            format.html
+          end
+        end
+
+        def unsubscribe
+          @subscription = Gluttonberg::Blog::CommentSubscription.where(:reference_hash => params[:reference]).first
+          unless @subscription.blank?
+            @subscription.destroy
+            flash[:notice] = "You are successfully unsubscribe from comments of \"#{@subscription.article.title}\""
+            redirect_to blog_article_path(:blog_id => @subscription.article.blog.slug, :id => @subscription.article.slug)
+          else
+            raise ActiveRecord::RecordNotFound.new
+          end
+        end
+
+        private
+          def find_blog
+            @blog = Gluttonberg::Blog::Weblog.where(:slug => params[:blog_id]).includes([:articles]).first
+            if @blog.blank?
+              @blog = Gluttonberg::Blog::Weblog.published.where(:previous_slug => params[:blog_id]).first
+            end
+            @blog = nil if @blog && current_user.blank? && !@blog.published?
+            raise ActiveRecord::RecordNotFound.new if @blog.blank?
+          end
+
+          def find_article
+            @article = Gluttonberg::Blog::Article.where(:slug => params[:id], :blog_id => @blog.id).first
+            find_article_by_previous_path
+            @article = nil if @article && current_user.blank? && !@article.published?
+            raise ActiveRecord::RecordNotFound.new if @article.blank?
+          end
+
+          def find_article_by_previous_path
+            if @article.blank?
+              @article = Gluttonberg::Blog::Article.published.where(:previous_slug => params[:id], :blog_id => @blog.id).first
+            end
+          end
+
+          def redirect_if_previous_path
+            if @blog.previous_slug == params[:blog_id] || @article.previous_slug == params[:id]
+              redirect_to blog_article_path(:blog_id => @blog.slug , :id => params[:id]) , :status => 301
+              true
+            else
+              false
+            end
+          end
+
+          def load_correct_version_and_localization
+            @article.load_localization(env['GLUTTONBERG.LOCALE'])
+            if current_user && params[:preview].to_s == "true"
+              Gluttonberg::AutoSave.load_version(@article.current_localization)
+            end
+          end
+
+      end
+    end
+  end
+end

data/app/controllers/gluttonberg/public/blog/blogs_controller.rb

@@ -0,0 +1,47 @@
+module Gluttonberg
+  module Public
+    module Blog
+      class BlogsController <  Gluttonberg::Public::BaseController
+
+        def index
+          @blogs = Gluttonberg::Blog::Weblog.published.all
+          if @blogs.blank?
+            redirect_to "/"
+          elsif @blogs.length == 1
+            if Gluttonberg.localized?
+              redirect_to blog_path(current_localization_slug , @blogs.first.slug)
+            else
+              redirect_to blog_path(:id =>@blogs.first.slug)
+            end
+          end
+        end
+
+        def show
+          @blog = Gluttonberg::Blog::Weblog.published.where(:slug => params[:id]).includes(:articles).first
+          return if find_by_previous_path
+          raise ActiveRecord::RecordNotFound.new if @blog.blank?
+          @articles = @blog.articles.published.order("published_at DESC").includes(:localizations).paginate(:page => params[:page], :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"))
+          @tags = Gluttonberg::Blog::Article.published.tag_counts_on(:tag)
+          respond_to do |format|
+             format.html
+             format.rss { render :layout => false }
+          end
+        end
+
+        private
+          def find_by_previous_path
+            if @blog.blank?
+              @blog = Gluttonberg::Blog::Weblog.published.where(:previous_slug => params[:id]).first
+
+              unless @blog.blank?
+                 redirect_to blog_path(:id => @blog.slug) , :status => 301
+                 return true
+              end
+            end
+            false
+          end
+
+      end
+    end
+  end
+end

data/app/controllers/gluttonberg/public/blog/comments_controller.rb

@@ -0,0 +1,54 @@
+module Gluttonberg
+  module Public
+    module Blog
+      class CommentsController <  Gluttonberg::Public::BaseController
+        def create
+          find_blog_and_article
+          prepare_comment
+
+          if @comment.save
+            send_notification
+            adjust_subscription
+          else
+          end
+          if Gluttonberg.localized?
+            redirect_to blog_article_path(current_localization_slug , @blog.slug, @article.slug)
+          else
+            redirect_to blog_article_path(:blog_id =>  @blog.slug, :id => @article.slug)
+          end
+        end
+
+        private
+
+          def send_notification
+            if Setting.get_setting("comment_notification") == "Yes" || @blog.moderation_required == true
+              User.all_super_admin_and_admins.each do |user|
+                BlogNotifier.comment_notification_for_admin(user , @article , @comment).deliver
+              end
+            end
+          end
+
+          def find_blog_and_article
+            @blog = Gluttonberg::Blog::Weblog.where(:slug => params[:blog_id]).first
+            @article = Gluttonberg::Blog::Article.where(:slug => params[:article_id], :blog_id => @blog.id).first
+          end
+
+          def prepare_comment
+            @comment = @article.comments.new(params[:comment])
+            @comment.blog_slug = params[:blog_id]
+            @comment.author_id = current_member.id if current_member
+          end
+
+          def adjust_subscription
+            @subscription = Gluttonberg::Blog::CommentSubscription.where(:article_id => @article.id , :author_email => @comment.writer_email).first
+            if @comment.subscribe_to_comments == "1" && @subscription.blank?
+              @subscription = Gluttonberg::Blog::CommentSubscription.create( {:article_id => @article.id , :author_email => @comment.writer_email , :author_name => @comment.writer_name } )
+            elsif (@comment.subscribe_to_comments.blank? || @comment.subscribe_to_comments == "0")  && !@subscription.blank?
+              #unsubscribe
+              @subscription.destroy
+            end
+          end
+      end
+    end
+  end
+end

data/app/helpers/gluttonberg/blog/application_helper.rb

@@ -0,0 +1,6 @@
+module Gluttonberg
+  module Blog
+    module ApplicationHelper
+    end
+  end
+end

data/app/mailers/blog_notifier.rb

@@ -0,0 +1,26 @@
+class BlogNotifier < Gluttonberg::BaseNotifier
+  def comment_notification(subscriber , article , comment,current_localization_slug = "")
+    setup_from
+    @subscriber = subscriber
+    @article = article
+    @comment = comment
+    @website_title = Gluttonberg::Setting.get_setting("title")
+    @article_url = blog_article_url(current_localization_slug, article.blog.slug, article.slug)
+    @unsubscribe_url = unsubscribe_article_comments_url(@subscriber.reference_hash)
+
+    mail(:to => @subscriber.author_email, :subject => "Re: [#{@website_title}] #{@article.title}")
+  end
+
+  def comment_notification_for_admin(admin , article , comment)
+    setup_email
+    @admin = admin
+    @article = article
+    @blog = @article.blog
+    @comment = comment
+    @website_title = Gluttonberg::Setting.get_setting("title")
+    @article_url = blog_article_url(:blog_id => article.blog.slug, :id => article.slug)
+
+    mail(:to => @admin.email, :subject => "Re: [#{@website_title}] #{@article.title}")
+  end
+
+end

data/app/models/gluttonberg/blog/article.rb

@@ -0,0 +1,120 @@
+module Gluttonberg
+  module Blog
+    class Article < ActiveRecord::Base
+      self.table_name = "gb_articles"
+      include Content::SlugManagement
+      include Content::Publishable
+      include Content::Localization
+      MixinManager.load_mixins(self)
+
+      belongs_to :blog, :foreign_key => 'blog_id', :class_name => "Gluttonberg::Blog::Weblog"
+      belongs_to :author, :class_name => "User"
+      belongs_to :user #created by
+      has_many :comments, :as => :commentable, :dependent => :destroy
+      has_many :localizations, :class_name => "Gluttonberg::ArticleLocalization" , :foreign_key => :article_id  , :dependent => :destroy
+
+      acts_as_taggable_on :article_category , :tag
+      attr_accessor :name
+      delegate :title , :body , :excerpt , :featured_image_id , :featured_image  , :to => :current_localization
+      attr_accessible :user_id, :blog_id, :author_id, :slug, :article_category_list, :tag_list, :disable_comments, :state, :published_at, :name
+      attr_accessible :user, :blog, :author
+      validates_presence_of :user_id, :author_id, :blog_id
+      delegate :version, :loaded_version,  :to => :current_localization
+
+      if ActiveRecord::Base.connection.table_exists?('gb_article_localizations')
+        is_localized(:parent_key => :article_id) do
+          self.table_name = "gb_article_localizations"
+          belongs_to :article  , :class_name => "Gluttonberg::Blog::Article"
+          belongs_to :locale
+
+          belongs_to :fb_icon , :class_name => "Gluttonberg::Asset" , :foreign_key => "fb_icon_id"
+          belongs_to :featured_image , :foreign_key => :featured_image_id , :class_name => "Gluttonberg::Asset"
+
+          is_versioned :non_versioned_columns => ['state' , 'disable_comments' , 'published_at' , 'article_id' , 'locale_id']
+
+          validates_presence_of :title
+          attr_accessible :article, :locale_id, :title, :featured_image_id, :excerpt, :body, :seo_title, :seo_keywords, :seo_description, :fb_icon_id, :article_id
+          delegate :state, :_publish_status, :state_changed?, :to => :article, :allow_nil => true
+
+          clean_html [:excerpt , :body]
+
+          def name
+            title
+          end
+
+          def slug
+            self.article.slug
+          end
+        end #is_localized
+      end
+
+      import_export_csv([:id, :slug, :title, :seo_title, :seo_description, :seo_keywords, :state], [:excerpt, :body])
+
+      def commenting_disabled?
+        !disable_comments.blank? && disable_comments
+      end
+
+      def moderation_required
+        if self.blog.blank?
+          true
+        else
+          self.blog.moderation_required
+        end
+      end
+
+      def current_localization
+        if @current_localization.blank?
+          load_default_localizations
+        end
+        @current_localization
+      end
+
+      # Load the matching localization as specified in the options
+      def load_localization(locale = nil)
+        if locale.blank? || locale.id.blank?
+          @current_localization = load_default_localizations
+        else
+          @current_localization = localizations.find_all{|l| l.locale_id == locale.id}.first
+        end
+        @current_localization
+      end
+
+      def load_default_localizations
+        @current_localization = localizations.find_all{ |l| l.locale_id == Locale.first_default.id }.first
+      end
+
+      def create_localizations(params)
+        Locale.all.each do |locale|
+          article_localization = localizations.new(params.merge({
+              :locale_id => locale.id
+            })
+          )
+          article_localization.current_user_id = self.user_id
+          article_localization.save
+        end
+      end
+
+      def duplicate
+        ActiveRecord::Base.transaction do
+          duplicated_article = self.dup
+          duplicated_article.state = "draft"
+          duplicated_article.created_at = Time.now
+          duplicated_article.published_at = nil
+
+          if duplicated_article.save
+            self.localizations.each do |loc|
+              dup_loc = loc.dup
+              dup_loc.article_id = duplicated_article.id
+              dup_loc.created_at = Time.now
+              dup_loc.save
+            end
+            duplicated_article
+          else
+            nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/app/models/gluttonberg/blog/comment.rb

@@ -0,0 +1,152 @@
+module Gluttonberg
+  module Blog
+    class Comment < ActiveRecord::Base
+      self.table_name = "gb_comments"
+      MixinManager.load_mixins(self)
+      attr_accessible :body , :author_name , :author_email , :author_website  , :subscribe_to_comments , :blog_slug
+
+      belongs_to :commentable, :polymorphic => true, :counter_cache => true
+      belongs_to :author, :class_name => "Gluttonberg::Member"
+
+      before_save :init_moderation
+      before_validation :spam_detection
+      after_save :send_notifications_if_needed
+
+      validates_presence_of :body
+
+      scope :all_approved, lambda { where("approved = ? AND ( spam = ? OR spam IS NULL)",true , false)}
+      scope :all_pending, lambda { where("moderation_required = ? AND ( spam = ? OR spam IS NULL)",true , false)}
+      scope :all_rejected, lambda { where("moderation_required = ? AND approved = ? AND ( spam = ? OR spam IS NULL)",false , false , false)}
+      scope :all_spam, lambda { where(:spam => true)}
+
+      attr_accessor :subscribe_to_comments , :blog_slug
+      attr_accessible :body , :author_name , :author_email , :author_website , :commentable_id , :commentable_type , :author_id
+      attr_accessible :user, :author, :commentable
+      alias_attribute :user_id, :author_id
+
+      can_be_flagged
+
+      clean_html [:body]
+
+      def moderate(params)
+        if params == "approve"
+          self.moderation_required = false
+          self.approved = true
+          self.spam = false
+          self.save
+        elsif params == "disapprove"
+          self.moderation_required = false
+          self.approved = false
+          self.save
+        else
+          #error
+        end
+      end
+
+      # these are helper methods for comment.
+      def writer_email
+        if self.author_email
+          self.author_email
+        elsif author
+          author.email
+        end
+      end
+
+      def writer_name
+        if self.author_name
+          self.author_name
+        elsif author
+          author.full_name
+        end
+      end
+
+      def approved=(val)
+        @approve_updated = !self.moderation_required && val && self.notification_sent_at.blank? #just got approved
+        write_attribute(:approved, val)
+      end
+
+      def self.spam_detection_for_all
+        self.all_pending.each do |c|
+          c.send("spam_detection")
+          c.save(:validate => false)
+        end
+      end
+
+      def black_list_author
+        author_string = _concat("", self.author_name)
+        author_string = _concat(author_string, self.author_email)
+        author_string = _concat(author_string, self.author_website)
+        unless author_string.blank?
+          gb_blacklist_settings = Gluttonberg::Setting.get_setting("comment_blacklist")
+          gb_blacklist_settings = _concat(gb_blacklist_settings, author_string)
+          Gluttonberg::Setting.update_settings("comment_blacklist" => gb_blacklist_settings)
+          Comment.spam_detection_for_all
+        end
+      end
+
+      protected
+        def init_moderation
+          if self.commentable.respond_to?(:moderation_required)
+            if self.commentable.moderation_required == false
+              self.approved = true
+              write_attribute(:moderation_required, false)
+            end
+          end
+          true
+        end
+
+        def send_notifications_if_needed
+          if @approve_updated == true
+            @approve_updated = false
+            CommentSubscription.notify_subscribers_of(self.commentable , self)
+          end
+        end
+
+        def spam_detection
+          unless self.body.blank?
+            dspam = Gluttonberg::Content::Despamilator.new(self.body)
+            self.spam = (dspam.score >= 1.0)
+            self.spam_score = dspam.score
+            self.check_author_details_for_spam
+          else
+            self.spam = true
+            self.spam_score = 1.0
+          end
+        end
+
+        def self._blank?(str)
+          str.blank? || str == "NULL" || str.length < 3
+        end
+
+        def _blank?(str)
+          self.class._blank?(str)
+        end
+
+        def self._concat(str1, str2)
+          unless _blank?(str2)
+            str1 = str1.blank? ? str2 : "#{str1}, #{str2}"
+          end
+          str1
+        end
+
+        def _concat(str1, str2)
+          self.class._concat(str1, str2)
+        end
+
+
+        def check_author_details_for_spam
+          unless self.spam
+            naughty_word_parser = Gluttonberg::Content::DespamilatorFilter::NaughtyWords.new
+            [:author_email, :author_name, :author_website].each do |field|
+              val = self.send(field)
+              if !val.blank? && naughty_word_parser.local_parse(val) >= 1.0
+                self.spam = true
+                break
+              end
+            end
+          end
+        end
+
+    end
+  end
+end