gluttonberg-core 2.6.4 → 3.0.0

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

@@ -1,44 +0,0 @@
-module Gluttonberg
-  module Public
-    class BlogsController <  Gluttonberg::Public::BaseController
-  
-      def index
-        if Gluttonberg::Blog.published.all.size == 0
-          redirect_to "/"
-        elsif Gluttonberg::Blog.published.all.size == 1
-          blog = Gluttonberg::Blog.published.first
-          if Gluttonberg.localized?
-            redirect_to blog_path(current_localization_slug , blog.slug)
-          else
-            redirect_to blog_path(:id =>blog.slug)
-          end  
-        else
-          @blogs = Gluttonberg::Blog.published.all
-        end
-      end
-  
-      def show
-        @blog = Gluttonberg::Blog.published.first(:conditions => {:slug => params[:id]}, :include => [:articles])
-        
-        if @blog.blank?
-          @blog = Gluttonberg::Blog.published.first(:conditions => {:previous_slug => params[:id]})
-          
-          unless @blog.blank?
-             redirect_to blog_path(:id => @blog.slug) , :status => 301
-             return
-          end
-        end
-        
-        raise ActiveRecord::RecordNotFound.new if @blog.blank?
-        @articles = @blog.articles.published
-        @tags = Gluttonberg::Article.published.tag_counts_on(:tag)
-        respond_to do |format|
-           format.html
-           format.rss { render :layout => false }
-        end
-        
-      end
-  
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-module Gluttonberg
-  module Public
-    class CommentsController <  Gluttonberg::Public::BaseController
-
-      def create
-        @blog = Gluttonberg::Blog.first(:conditions => {:slug => params[:blog_id]})
-        @article = Gluttonberg::Article.first(:conditions => {:slug => params[:article_id], :blog_id => @blog.id})
-        @comment = @article.comments.new(params[:comment])
-        @comment.blog_slug = params[:blog_id]
-        @comment.author_id = current_member.id if current_member
-        if @comment.save
-          if Setting.get_setting("comment_notification") == "Yes" || @blog.moderation_required == true
-            User.all_super_admin_and_admins.each do |user|
-              Notifier.comment_notification_for_admin(user , @article , @comment).deliver
-            end
-          end
-
-          @subscription = CommentSubscription.find(:first , :conditions => {:article_id => @article.id , :author_email => @comment.writer_email })
-          if @comment.subscribe_to_comments == "1" && @subscription.blank?
-            @subscription = 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
-        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 current_localization_slug
-           if @locale
-             @locale.slug
-           else
-             nil
-           end
-        end
-    end
-
-  end
-end

data/app/models/gluttonberg/article.rb

@@ -1,73 +0,0 @@
-module Gluttonberg
-  class Article < ActiveRecord::Base
-    self.table_name = "gb_articles"
-    include Content::SlugManagement
-    include Content::Publishable
-
-    belongs_to :blog
-    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
-
-    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.where("locale_id = ?", locale.id).first
-      end
-      @current_localization
-    end
-
-    def load_default_localizations
-      @current_localization = localizations.where(:locale_id => Locale.first_default.id).first
-    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

data/app/models/gluttonberg/article_localization.rb

@@ -1,21 +0,0 @@
-module Gluttonberg
-  class ArticleLocalization < ActiveRecord::Base
-    self.table_name = "gb_article_localizations"
-    belongs_to :article  , :class_name => "Gluttonberg::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
-
-    clean_html [:excerpt , :body]
-
-    def name
-      title
-    end
-  end
-end

data/app/models/gluttonberg/blog.rb

@@ -1,19 +0,0 @@
-module Gluttonberg
-  class Blog < ActiveRecord::Base
-    self.table_name = "gb_blogs"
-    include Content::Publishable
-    include Content::SlugManagement
-
-    belongs_to :user
-    has_many :articles, :dependent => :destroy
-
-    validates_presence_of :name
-
-    is_versioned :non_versioned_columns => ['state' ,'published_at' , 'moderation_required' ]
-
-    acts_as_taggable_on :tag
-    clean_html [:description]
-    attr_accessible :user_id, :name, :slug, :description, :moderation_required, :seo_title, :seo_keywords, :seo_description, :fb_icon_id, :state, :published_at
-
-  end
-end

data/app/models/gluttonberg/comment.rb

@@ -1,142 +0,0 @@
-module Gluttonberg
-  class Comment < ActiveRecord::Base
-    self.table_name = "gb_comments"
-
-    attr_accessible :body , :author_name , :author_email , :author_website  , :subscribe_to_comments , :blog_slug
-
-    belongs_to :commentable, :polymorphic => true
-    belongs_to :article
-    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, :conditions => ["approved = ? AND ( spam = ? OR spam IS NULL)",true , false]
-    scope :all_pending, :conditions => ["moderation_required = ? AND ( spam = ? OR spam IS NULL)",true , false]
-    scope :all_rejected, :conditions => ["moderation_required = ? AND approved = ? AND ( spam = ? OR spam IS NULL)",false , false , false]
-    scope :all_spam, :conditions => { :spam => true }
-
-    attr_accessor :subscribe_to_comments , :blog_slug
-    attr_accessible :body , :author_name , :author_email , :author_website , :commentable_id , :commentable_type , :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
-
-    def self.all_comments_count
-      self.count
-    end
-
-    def self.approved_comments_count
-      self.all_approved.count
-    end
-
-    def self.rejected_comments_count
-      self.all_rejected.count
-    end
-
-    def self.pending_comments_count
-      self.all_pending.count
-    end
-
-    def self.spam_comments_count
-      self.all_spam.count
-    end
-
-
-    def user_id
-      self.author_id
-    end
-
-    def user_id=(new_id)
-      self.author_id=new_id
-    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.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
-
-    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
-          unless self.spam
-            naughty_word_parser = Gluttonberg::Content::DespamilatorFilter::NaughtyWords.new
-            if !self.author_email.blank? && naughty_word_parser.local_parse(self.author_email) >= 1.0
-              self.spam = true
-            elsif !self.author_name.blank? && naughty_word_parser.local_parse(self.author_name) >= 1.0
-              self.spam = true
-            elsif !self.author_website.blank? && naughty_word_parser.local_parse(self.author_website) >= 1.0
-              self.spam = true
-            end
-          end
-        else
-          self.spam = true
-          self.spam_score = 1.0
-        end
-      end
-
-  end
-end

data/app/models/gluttonberg/comment_subscription.rb

@@ -1,28 +0,0 @@
-module Gluttonberg
-  class CommentSubscription < ActiveRecord::Base
-    self.table_name = "gb_comment_subscriptions"
-
-    before_save    :generate_reference_hash
-    belongs_to     :article
-
-    attr_accessible :article_id , :author_email , :author_name
-
-    def self.notify_subscribers_of(article , comment)
-      subscribers = self.find(:all , :conditions => {:article_id => article.id})
-      subscribers.each do |subscriber|
-        unless subscriber.author_email == comment.writer_email
-          Notifier.delay.comment_notification(subscriber , article , comment ) #.deliver # its using delayed job but i am setting sent time immediately
-          comment.notification_sent_at = Time.now
-          comment.save
-        end
-      end
-    end
-
-    def generate_reference_hash
-      unless self.reference_hash
-        self.reference_hash = Digest::SHA1.hexdigest(Time.now.to_s + self.author_email + self.article_id.to_s)
-      end
-    end
-
-  end
-end

data/app/models/gluttonberg/help.rb

@@ -1,48 +0,0 @@
-module Gluttonberg
-    class Help
-      # Default help paths
-      @@gluttonberg_help_path = "help"
-    
-      # first find help in engine, if it founds return true
-      # otherwise find in application. 
-      def self.help_available?(opts)
-        status = help_available_in(:engine , opts)
-        status ? status : help_available_in(:application , opts)
-      end
-      
-      # find help file in 'where'. if its :application then look into application 
-      # otherwise look in engine
-      def self.help_available_in(where , opts)
-        if where == :application
-          dir = template_dir_in_application(opts)
-        else
-          dir = template_dir_in_engine(opts)
-        end
-        
-        if dir
-          Dir.glob(File.join(dir ,  "/*") ).each do |template|
-            return true if template.match(opts[:page].to_s)
-          end
-        end
-        false
-      end
-    
-      def self.path_to_template(opts)
-        dir = template_dir(opts)
-        "#{dir}/#{opts[:page]}"
-      end
-    
-      def self.template_dir(opts)        
-        "#{@@gluttonberg_help_path}/#{opts[:controller]}"
-      end
-      
-      def self.template_dir_in_engine(opts)
-        File.join(Engine.root , "app/views" , template_dir(opts)   )
-      end
-      
-      def self.template_dir_in_application(opts)
-        File.join(Rails.root , "app/views" , template_dir(opts)   )
-      end
-      
-    end
-end

data/app/views/gluttonberg/admin/content/articles/_form.html.haml

@@ -1,115 +0,0 @@
-
-- unless @article_localization.blank?
-  /= version_listing(@article_localization.versions , @article_localization )
-
-= form_for(@article_localization, :url => url , :html => {:class => "validation"}) do  |f|
-  = gb_error_messages_for(@article_localization)
-  .span5
-    .tabbable
-      .versions.page_content_form
-        - unless action_name == "new" || action_name == "create"
-          - if Gluttonberg.localized? && Gluttonberg::Locale.all.length > 1
-            .btn-group
-              %a{ :class => "btn dropdown-toggle" , "data-toggle" => "dropdown", :href => "#"}
-                Editing #{@article_localization.locale.name} Content
-                %span.caret
-              %ul.dropdown-menu
-                - for locale in Gluttonberg::Locale.all
-                  - localization = Gluttonberg::ArticleLocalization.find(:first , :conditions => { :article_id => @article.id , :locale_id => locale.id } )
-                  %li
-                    %a{:href => edit_admin_blog_article_path(@blog, @article , :localization_id => localization.id) ,:id=>"edit_content_tab",:class=>"button"}
-                      = "Edit #{localization.locale.name}"
-      %ul.nav.nav-tabs
-        %li.active
-          %a{:href => "#content", "data-toggle" => "tab" }
-            Content
-        %li
-          %a{:href => "#seo", "data-toggle" => "tab"  }
-            SEO
-      .tab-content
-        .tab-pane.active#content
-          .pad
-            %p
-              = f.fields_for :article , @article do |article_form|
-                %p
-                  = article_form.hidden_field(:user_id, :value => current_user.id) if @article.user_id.blank?
-                  = article_form.hidden_field(:blog_id, :value => @blog.id) if @article.blog_id.blank?
-              %p
-                = f.label :title
-                = f.text_field(:title, :id => "page_title" , :class => "required")
-
-              %p
-                #page_slug_holder
-                  %span.domain
-                    = current_domain
-                  -##page_slug
-                    %span{:donotedit => true}
-                      = @article.slug
-                    = f.text_field(:slug, :id => 'page_hidden_slug')
-              .clear
-
-
-              = f.fields_for :article , @article do |article_form|
-                %p
-                  = article_form.label :author
-                  = article_form.select("author_id" ,  @authors.collect{|a| [a.email , a.id] } , :class => "required" )
-              %p
-                = f.label :featured_image_id
-                = f.asset_browser( :featured_image_id ,  opts = { :filter => "image"   } )
-
-              %p
-                = f.label :excerpt
-                = f.text_area(:excerpt  , :class => "jwysiwyg" )
-              %p
-                = f.label :body, "Content"
-                = f.text_area(:body  , :class => "jwysiwyg" )
-
-        .tab-pane#seo
-          .pad
-            = f.fields_for :article , @article do |article_form|
-              .seo_body
-                %p
-                  = article_form.label :slug
-                  = article_form.text_field(:slug, :id => 'page_slug' , :donotmodify => (action_name == "edit"  || action_name == "update"))
-                %p
-                  = f.label :seo_title
-                  = f.text_field :seo_title , :class => "span4 "
-                %p
-                  = f.label :seo_keywords , "Keywords"
-                  = f.text_area :seo_keywords , :class => "span4 "   , :rows => 3
-                %p
-                  = f.label :seo_description , "Description"
-                  = f.text_area :seo_description , :class => "span4 " , :rows => 3
-                %p
-                  = f.label :fb_icon_id , "Facebook Icon"
-                  = f.asset_browser :fb_icon_id , :class => "" , :filter => "image"
-
-
-  .span4
-
-    = f.fields_for :article , @article do |article_form|
-      %legend Categories & Tags
-      %p
-        = article_form.label :article_category_list , "Categories"
-        = article_form.text_field(:article_category_list, :class => "tags" , :rel => tags_string("article_category") )
-      %p
-        = article_form.label :tag_list , "Tags"
-        = article_form.text_field(:tag_list, :class => "tags" , :rel => tags_string("tag") )
-      %p
-        %em seperate categories & tags with  a comma
-
-      %legend Comments
-      %p
-        = article_form.label :disable_comments
-        = article_form.check_box(:disable_comments)
-      -# - unless @article.blank?
-      -#   %p
-      -#     = link_to "View Comments", admin_blog_article_comments_path(@blog, @article) , :class => "btn"
-    - if can? :publish , Gluttonberg::Article
-      %legend
-        Publish
-      = f.fields_for :article , @article do |article_form|
-        = article_form.publisable_dropdown
-    = form_controls(admin_blog_articles_path(@blog))
-
-= enable_jwysiwyg_on_class("jwysiwyg")