gluttonberg-core 2.5.5 → 2.5.6

data/app/assets/javascripts/gb_application.js

@@ -296,6 +296,20 @@ var AssetBrowser = {
       e.preventDefault();
     });
 
+    // same height for all elements within same row
+    $.each(AssetBrowser.browser.find(".tab-pane") , function(index , element){
+      AssetBrowser.sameHeightForAllElementsOfSameRow($(element));
+    });
+
+    try{
+      $().collapse({parent: "#accordion_for_collections"});
+    }catch(e){
+      console.log(e);
+    }
+
+
+
+
     $("#assetsDialog").css({
       height: ($(window).height()*0.9) + "px",
       width: ($(window).width()*0.7) + "px",
@@ -322,6 +336,26 @@ var AssetBrowser = {
 
     })
   },
+  sameHeightForAllElementsOfSameRow: function(parent_element){
+
+    var all_spans = parent_element.find(".thumbnails .span3");
+    var row_num = 1;
+    var ASSET_MAX_COLUMNS = 5;
+    var row_max_height = 0;
+    $.each(all_spans , function(index , element){
+      if($(element).height() > row_max_height){
+        row_max_height = $(element).height();
+      }
+      $(element).attr('data-row' , row_num);
+      if( (index+1) % ASSET_MAX_COLUMNS == 0 ){
+        if(row_max_height > 0){
+          parent_element.find("[data-row="+row_num+"]").height(row_max_height);
+        }
+        row_num++;
+        row_max_height = 0;
+      }
+    });
+  },
   resizeDisplay: function() {
     // var newHeight = AssetBrowser.browser.innerHeight() - AssetBrowser.offsetHeight;
     // AssetBrowser.display.height(newHeight);

data/app/assets/stylesheets/gb_admin-override.sass

@@ -491,6 +491,15 @@ legend.collapsed
     -moz-border-radius: 3px 0 0 3px
     border-radius: 3px 0 0 3px
 
+  span.gap
+    float: left
+    padding: 0 30px
+    line-height: 34px
+    text-decoration: none
+    border: 1px solid #ddd
+    border-left-width: 0
+    font-weight: bold
+
 
 table
   thead
@@ -570,4 +579,11 @@ table
     :float left
 
 form .span5 input.span2, form .span5 textarea.span2, form .span5 .uneditable-input.span2
-  width: 130px
+  width: 130px
+
+.editable
+  :display block
+  :padding-left 20px
+  :background url('/assets/gb_icon_blog.png') no-repeat
+  &:hover
+    :cursor pointer

data/app/controllers/gluttonberg/admin/asset_library/assets_controller.rb

@@ -75,7 +75,6 @@ module Gluttonberg
             end
           end # category#all
           page = params[:page].blank? ? 1 : params[:page].to_i
-          puts "----#{Gluttonberg::Setting.get_setting("number_of_per_page_items")}   #{page}"
           @assets = @assets.paginate( :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items") , :page => page ).order(get_order)
         end
 
@@ -84,7 +83,10 @@ module Gluttonberg
         end
 
         def destroy_assets_in_bulk
-          @assets = Asset.delete_all(:id => params[:asset_ids].split(","))
+          @assets = Asset.where(:id => params[:asset_ids].split(",")).all
+          @assets.each do |asset|
+            asset.destroy
+          end
           redirect_to "/admin/browse/all/page/1"
         end
 

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

@@ -2,32 +2,32 @@
 
 module Gluttonberg
   module Admin
-    module Content    
+    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]  
+        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])
+          @articles = Article.where( conditions).order("created_at DESC").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)
@@ -42,7 +42,7 @@ module Gluttonberg
             render :edit
           end
         end
-        
+
         def edit
           @authors = User.all
           unless params[:version].blank?
@@ -50,7 +50,7 @@ module Gluttonberg
             @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])
@@ -59,7 +59,7 @@ module Gluttonberg
             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}) "
@@ -69,22 +69,22 @@ module Gluttonberg
             end
 
             flash[:notice] = "The article was successfully updated."
-            redirect_to admin_blog_articles_path(@blog)
+            redirect_to edit_admin_blog_article_path(@article.blog, @article)
           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), 
+            :return_url => admin_blog_articles_path(@blog),
             :warning    => ""
           )
         end
-        
+
         def destroy
           title = @article.current_localization.title
           if @article.destroy
@@ -107,13 +107,13 @@ module Gluttonberg
             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}
@@ -124,7 +124,7 @@ module Gluttonberg
             end
             @article = Article.find(:first , :conditions => {:id => params[:id]})
           end
-          
+
           def authorize_user
             authorize! :manage, Gluttonberg::Article
           end
@@ -132,7 +132,7 @@ module Gluttonberg
           def authorize_user_for_destroy
             authorize! :destroy, Gluttonberg::Article
           end
-        
+
       end
     end
   end

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

@@ -2,68 +2,125 @@
 
 module Gluttonberg
   module Admin
-    module Content    
+    module Content
       class CommentsController < Gluttonberg::Admin::BaseController
         include ActionView::Helpers::TextHelper
-        
-        before_filter :find_blog
-        before_filter :find_article ,  :except => [:index]
+
+        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.paginate(:per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items"), :page => params[:page])
+          @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], :conditions => {:commentable_type => "Gluttonberg::Article", :commentable_id => @article.id})
+          @comment = Comment.find(params[: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), 
+            :url        => admin_comment_destroy_path(@comment),
+            :return_url => :back,
             :warning    => ""
           )
         end
-        
-        def moderation 
+
+        def moderation
           authorize_user_for_moderation
-          @comment = Comment.find(params[:id], :conditions => {:commentable_type => "Gluttonberg::Article", :commentable_id => @article.id})
+          @comment = Comment.find(params[: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)
+          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_blog_article_comments_path(@blog, @article)
+            redirect_to admin_pending_comments_path()
           else
             flash[:error] = "There was an error deleting the comment."
-            redirect_to admin_blog_article_comments_path(@blog, @article)
+            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

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

@@ -16,7 +16,7 @@ module Gluttonberg
         end
 
         if Comment.table_exists?
-          @comments = Comment.find(:all , :conditions => {:commentable_type => "Gluttonberg::Article" , :moderation_required => true } , :order => "created_at DESC" , :limit => 3)
+          @comments = Comment.all_pending.where({:commentable_type => "Gluttonberg::Article" , :moderation_required => true }).order("created_at DESC").limit(5)
           @article = Article.new
           @article_localization = ArticleLocalization.new(:article => @article , :locale_id => Locale.first_default.id)
           @blogs = Gluttonberg::Blog.all

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

@@ -1,11 +1,12 @@
 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].merge(:blog_slug => params[: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
@@ -13,16 +14,16 @@ module Gluttonberg
               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 
+            @subscription.destroy
           end
         else
-          
+
         end
         if Gluttonberg.localized?
           redirect_to blog_article_path(current_localization_slug , @blog.slug, @article.slug)
@@ -30,8 +31,8 @@ module Gluttonberg
           redirect_to blog_article_path(:blog_id =>  @blog.slug, :id => @article.slug)
         end
       end
-  
-      private 
+
+      private
         def current_localization_slug
            if @locale
              @locale.slug
@@ -40,6 +41,6 @@ module Gluttonberg
            end
         end
     end
-    
+
   end
 end

data/app/helpers/gluttonberg/admin.rb

@@ -136,7 +136,7 @@ module Gluttonberg
       def nav_link(*args)
         class_names = "button"
         class_names = "#{class_names} #{args[2][:class]}" if args.length >= 3
-        content_tag(:li, link_to(args[0] , args[1] , :title => args[0]), :class => class_names)
+        content_tag(:li, active_link_to(args[0] , args[1] , :title => args[0]), :class => class_names)
       end
 
       # Writes out the back control for the sub nav.
@@ -279,7 +279,7 @@ module Gluttonberg
 
 
       def honeypot_field_tag
-        html = label_tag(Rails.configuration.honeypot_field_name , 'Please leave this field empty:' )
+        html = label_tag(Rails.configuration.honeypot_field_name , Rails.configuration.honeypot_field_name.humanize )
         html << text_field_tag( Rails.configuration.honeypot_field_name )
         content_tag :div , html , :class => Rails.configuration.honeypot_field_name , :style => "display:none"
       end
@@ -350,7 +350,7 @@ module Gluttonberg
                    height : '20px',
                    cancel    : 'Cancel',
                    submit    : 'OK',
-                   indicator : '#{image_tag('/assets/spinner.gif')}'
+                   indicator : '#{image_tag('/assets/gb_spinner.gif')}'
                 };
                 $.extend(args, #{args.to_json});
                 $(".editable[data-id='#{object.id}'][data-name='#{name}']").editable("#{update_url}", args);

data/app/helpers/gluttonberg/asset_library.rb

@@ -1,20 +1,23 @@
 module Gluttonberg
     module AssetLibrary
 
-       #  nice and clean public url of assets
-       def asset_url(asset , opts = {})
-         url = ""
-         if Rails.env=="development"
+      #  nice and clean public url of assets
+      def asset_url(asset , opts = {})
+        url = ""
+        if Rails.configuration.asset_storage == :s3
+          url = asset.url
+        else
+          if Rails.env=="development"
            url = "http://#{request.host}:#{request.port}/user_asset/#{asset.asset_hash[0..3]}/#{asset.id}"
-         else
+          else
            url = "http://#{request.host}/user_asset/#{asset.asset_hash[0..3]}/#{asset.id}"
-         end
+          end
 
-         if opts[:thumb_name]
+          if opts[:thumb_name]
            url << "/#{opts[:thumb_name]}"
-         end
-
-         url
+          end
+        end
+          url
        end
 
 
@@ -134,7 +137,7 @@ module Gluttonberg
        end
 
        def asset_panel(assets, name_or_id , type )
-          render :partial => "gluttonberg/admin/shared/asset_panel.html" , :locals => {:assets => assets , :name_or_id => name_or_id , :type => type}
+          render :partial => "/gluttonberg/admin/shared/asset_panel" , :locals => {:assets => assets , :name_or_id => name_or_id , :type => type} , :formats => [:html]
        end
 
 

data/app/models/gluttonberg/asset.rb

@@ -4,7 +4,7 @@ module Gluttonberg
       has_many :set_elements, :as => :element
       has_many :asset_thumbnails
 
-      after_save  :update_file
+      #after_save  :update_file
       before_validation  :set_category_and_type
 
       acts_as_taggable_on :locations , :characters , :themes, :photographers
@@ -27,6 +27,8 @@ module Gluttonberg
       attr_accessible :description, :synopsis, :copyrights, :year_of_production, :duration
       attr_accessible :artist_name, :link, :width, :height, :alt , :processed, :copied_to_s3
 
+      attr_accessor :type
+
       # constants for formatted file size
       GIGA_SIZE = 1073741824.0
       MEGA_SIZE = 1048576.0
@@ -78,9 +80,9 @@ module Gluttonberg
         self.asset_type = AssetType.for_file(mime_type, file_name)
         cat = self.category.to_s.downcase
         if cat == "image"
-          self[:type]  = "Photo"
+          self.type = "Photo"
         elsif cat == "video"
-          self[:type]  = "Video"
+          self.type = "Video"
         end
       end
 
@@ -165,9 +167,9 @@ module Gluttonberg
       private
 
       # make a new asset folder if not exist. then make backup of asset. generate thumbnails
-      def update_file
-        update_file_on_disk
-      end
+      # def update_file
+      #   update_file_on_disk
+      # end
 
 
   end

data/app/models/gluttonberg/comment.rb

@@ -9,11 +9,15 @@ module Gluttonberg
     belongs_to :author, :class_name => "Gluttonberg::Member"
 
     before_save :init_moderation
+    before_validation :spam_detection
     after_save :send_notifications_if_needed
 
-    scope :all_approved, :conditions => { :approved => true }
-    scope :all_pending, :conditions => { :moderation_required => true }
-    scope :all_rejected, :conditions => { :approved => false , :moderation_required => false }
+    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
@@ -26,6 +30,7 @@ module Gluttonberg
         if params == "approve"
           self.moderation_required = false
           self.approved = true
+          self.spam = false
           self.save
         elsif params == "disapprove"
           self.moderation_required = false
@@ -36,6 +41,27 @@ module Gluttonberg
         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
@@ -66,6 +92,13 @@ module Gluttonberg
       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)
@@ -84,5 +117,26 @@ module Gluttonberg
         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

@@ -5,6 +5,8 @@ module Gluttonberg
     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|