community_engine 2.3.1 → 2.3.2

data/app/models/clipping_image.rb

@@ -2,8 +2,8 @@ class ClippingImage < Asset
   include UrlUpload
   
   has_attached_file :asset, configatron.clipping.paperclip_options
-  validates_attachment_presence :asset
-  validates_attachment_content_type :asset, :content_type => configatron.clipping.validation_options.content_type
-  validates_attachment_size :asset, :less_than => configatron.clipping.validation_options.max_size.to_i.megabytes
-  
+  validates_attachment_presence :asset, :message => :photo_presence_error.l
+  validates_attachment_content_type :asset, :content_type => configatron.clipping.validation_options.content_type, :message => :photo_content_type_error.l
+  validates_attachment_size :asset, :less_than => configatron.clipping.validation_options.max_size.to_i.megabytes, :message => :photo_size_limit_error.l(:count => configatron.clipping.validation_options.max_size)
+
 end

data/app/models/comment.rb

@@ -13,6 +13,8 @@ class Comment < ActiveRecord::Base
   validates_length_of :comment, :maximum => 2000
 
   before_save :whitelist_attributes
+  after_create :send_notifications
+  after_save :send_notifications, :if => Proc.new{|record| record.role_change.eql?(['pending', 'published']) }
 
   validates_presence_of :user, :unless => Proc.new{|record| configatron.allow_anonymous_commenting }
   validates_presence_of :author_email, :unless => Proc.new{|record| record.user }  #require email unless logged in
@@ -20,7 +22,7 @@ class Comment < ActiveRecord::Base
   validates_format_of :author_url, :with => /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)/ix, :unless => Proc.new{|record| record.user }
   validate :check_spam
 
-  acts_as_activity :user, :if => Proc.new{|record| record.user } #don't record an activity if there's no user
+  acts_as_activity :user, :if => Proc.new{|record| record.user && !record.pending? } #don't record an activity if there's no user
 
   def self.find_photo_comments_for(user)
     Comment.find(:all, :conditions => ["recipient_id = ? AND commentable_type = ?", user.id, 'Photo'], :order => 'created_at DESC')
@@ -29,13 +31,14 @@ class Comment < ActiveRecord::Base
   def previous_commenters_to_notify
     # only send a notification on recent comments
     # limit the number of emails we'll send (or posting will be slooowww)
-
-    User.find(:all,
-      :conditions => ["users.id NOT IN (?) AND users.notify_comments = ?
-                      AND commentable_id = ? AND commentable_type = ?
-                      AND comments.notify_by_email = ?
-                      AND comments.created_at > ?", [user_id, recipient_id.to_i], true, commentable_id, commentable_type, true, 2.weeks.ago],
-      :include => :comments_as_author, :limit => 20)
+    users = User.includes(:comments_as_author).limit(20)
+    users = users.where(:notify_comments => true).where('users.id NOT IN (?)', [user_id, recipient_id.to_i])
+    users = users.where(:comments => {
+        :commentable_id => commentable_id,
+        :commentable_type =>  commentable_type,
+        :notify_by_email => true
+        })
+    users = users.where('comments.created_at > ?', 2.weeks.ago)
   end
 
   def commentable_name
@@ -71,7 +74,7 @@ class Comment < ActiveRecord::Base
   end
 
   def should_notify_recipient?
-    return unless recipient && recipient.email
+    return false unless recipient && recipient.email
     return false if recipient.eql?(user)
     return false unless recipient.notify_comments?
     true
@@ -92,6 +95,7 @@ class Comment < ActiveRecord::Base
 
   def send_notifications
     return if commentable.respond_to?(:send_comment_notifications?) && !commentable.send_comment_notifications?
+    return if pending?
     UserNotifier.comment_notice(self).deliver if should_notify_recipient?
     self.notify_previous_commenters
     self.notify_previous_anonymous_commenters if configatron.allow_anonymous_commenting
@@ -109,10 +113,14 @@ class Comment < ActiveRecord::Base
 
   def check_spam
     if !configatron.akismet_key.nil? && self.spam?
-      self.errors.add(:base, :comment_spam_error.l)
+      self.role = 'pending'
     end
   end
 
+  def pending?
+    role.eql?('pending')
+  end
+
 
   protected
   def whitelist_attributes

data/app/models/event.rb

@@ -12,23 +12,23 @@ class Event < ActiveRecord::Base
   has_many :attendees, :source=>:user, :through=>:rsvps
 
   attr_protected :user_id
-  
+
   #Procs used to make sure time is calculated at runtime
-  scope :upcoming, lambda { 
+  scope :upcoming, lambda {
     where('end_time > ?' , Time.now).order('start_time ASC')
   }
-  scope :past, lambda { 
+  scope :past, lambda {
     where('end_time <= ?' , Time.now).order('start_time DESC')
-  }  
-  
-  
-  acts_as_commentable
+  }
+
+
+  acts_as_moderated_commentable
 
   # Used by acts_as_commentable
   def owner
     self.user
-  end    
-  
+  end
+
   def rsvped?(user)
     self.rsvps.find_by_user_id(user)
   end
@@ -52,10 +52,10 @@ class Event < ActiveRecord::Base
   def spans_days?
     (end_time - start_time) >= 86400
   end
-  
+
   protected
     def start_time_cannot_be_before_end_time
       errors.add("start_time", " must be before end time") unless start_time && end_time && (start_time < end_time)
-    end  
-  
+    end
+
 end

data/app/models/homepage_feature.rb

@@ -1,9 +1,9 @@
 class HomepageFeature < ActiveRecord::Base  
   has_attached_file :image, configatron.feature.paperclip_options.to_hash
-  validates_attachment_presence :image
-  validates_attachment_content_type :image, :content_type => configatron.feature.validation_options.content_type
-  validates_attachment_size :image, :less_than => configatron.feature.validation_options.max_size.to_i.megabytes
-  
+  validates_attachment_presence :image, :message => :photo_presence_error.l
+  validates_attachment_content_type :image, :content_type => configatron.feature.validation_options.content_type, :message => :photo_content_type_error.l
+  validates_attachment_size :image, :less_than => configatron.feature.validation_options.max_size.to_i.megabytes, :message => :photo_size_limit_error.l(:count => configatron.feature.validation_options.max_size)
+
   attr_accessible :url, :title, :description, :image
 
   validates_presence_of :url

data/app/models/message.rb

@@ -2,8 +2,8 @@ class Message < ActiveRecord::Base
   attr_accessor :to
   attr_accessor :reply_to
 
-  attr_accessible :to, :subject, :body, :recipient, :sender, :recipient_id, :sender_id
-  
+  attr_accessible :to, :subject, :body, :recipient, :sender, :recipient_id, :sender_id, :parent_id
+
   belongs_to :sender,     :class_name => 'User', :foreign_key => 'sender_id', :inverse_of => :sent_messages
   belongs_to :recipient,  :class_name => 'User', :foreign_key => 'recipient_id', :inverse_of => :received_messages
 

data/app/models/metro_area.rb

@@ -9,7 +9,7 @@ class MetroArea < ActiveRecord::Base
   validates_presence_of :country_id
   validates_presence_of :name
 
-	acts_as_commentable
+  acts_as_moderated_commentable
 
   def to_s
     name

data/app/models/photo.rb

@@ -1,13 +1,13 @@
 class Photo < ActiveRecord::Base
   include UrlUpload
 
-  acts_as_commentable
+  acts_as_moderated_commentable
   belongs_to :album
 
   has_attached_file :photo, configatron.photo.paperclip_options.to_hash
-  validates_attachment_presence :photo, :unless => Proc.new{|record| record.photo_remote_url }
-  validates_attachment_content_type :photo, :content_type => configatron.photo.validation_options.content_type
-  validates_attachment_size :photo, :less_than => configatron.photo.validation_options.max_size.to_i.megabytes
+  validates_attachment_presence :photo, :unless => Proc.new{|record| record.photo_remote_url }, :message => :photo_presence_error.l
+  validates_attachment_content_type :photo, :content_type => configatron.photo.validation_options.content_type, :message => :photo_content_type_error.l
+  validates_attachment_size :photo, :less_than => configatron.photo.validation_options.max_size.to_i.megabytes, :message => :photo_size_limit_error.l(:count => configatron.photo.validation_options.max_size)
 
   attr_accessor :crop_x, :crop_y, :crop_w, :crop_h, :photo_remote_url
   after_update :reprocess_photo, :if => :cropping?

data/app/models/poll.rb

@@ -4,7 +4,7 @@ class Poll < ActiveRecord::Base
   validates_presence_of :post
   has_many :votes, :dependent => :destroy
   belongs_to :post
-  attr_accessible :question
+  attr_accessible :question, :post_id, :post
       
   def voted?(user)
     !self.votes.find_by_user_id(user.id).nil?

data/app/models/post.rb

@@ -1,44 +1,44 @@
 class Post < ActiveRecord::Base
   include Rakismet::Model
   rakismet_attrs :comment_type => 'post'
-  attr_protected :akismet_attrs  
-  
-  
-  acts_as_commentable
+  attr_protected :akismet_attrs
+
+  acts_as_moderated_commentable
+
   acts_as_taggable
   acts_as_activity :user, :if => Proc.new{|r| r.is_live?}
   acts_as_publishable :live, :draft
-  
+
   belongs_to :user
   belongs_to :category
   has_many   :polls, :dependent => :destroy
   has_many :favorites, :as => :favoritable, :dependent => :destroy
-  
+
   validates_presence_of :raw_post
   validates_presence_of :title
   validates_presence_of :user
   validates_presence_of :published_at, :if => Proc.new{|r| r.is_live? }
-  
+
   before_save :transform_post, :if => Proc.new{|r| r.raw_post_changed? }
   before_validation :set_published_at
-  
+
   after_save do |post|
     activity = Activity.find_by_item_type_and_item_id('Post', post.id)
     if post.is_live? && !activity
-      post.create_activity_from_self 
+      post.create_activity_from_self
     elsif post.is_draft? && activity
       activity.destroy
     end
   end
-    
+
   attr_accessor :invalid_emails
 
   attr_accessible :category_id, :title, :raw_post, :published_as, :send_comment_notifications
-  
+
   # Class Methods
   class << self
-    
-    # Scopes    
+
+    # Scopes
     def by_featured_writers
       where("users.featured_writer = ?", true).includes(:user)
     end
@@ -46,21 +46,21 @@ class Post < ActiveRecord::Base
       order('posts.view_count DESC')
     end
     def since(days)
-      where("posts.published_at > ?", days.ago)    
+      where("posts.published_at > ?", days.ago)
     end
     def recent
-      order("posts.published_at DESC")    
+      order("posts.published_at DESC")
     end
-  
+
     def find_related_to(post, options = {})
-      options.reverse_merge!({:limit => 8, 
-          :order => 'published_at DESC', 
+      options.reverse_merge!({:limit => 8,
+          :order => 'published_at DESC',
           :conditions => [ 'posts.id != ? AND published_as = ?', post.id, 'live' ]
       })
 
       limit(options[:limit]).order(options[:order]).where(options[:conditions]).tagged_with(post.tag_list, :any => true)
     end
-    
+
     def find_recent(options = {:limit => 5})
       recent.find :all, options
     end
@@ -76,7 +76,7 @@ class Post < ActiveRecord::Base
     end
 
     def find_most_commented(limit = 10, since = 7.days.ago)
-      Post.find(:all, 
+      Post.find(:all,
         :select => 'posts.*, count(*) as comments_count',
         :joins => "LEFT JOIN comments ON comments.commentable_id = posts.id",
         :conditions => ['comments.commentable_type = ? AND posts.published_at > ?', 'Post', since],
@@ -84,24 +84,24 @@ class Post < ActiveRecord::Base
         :order => 'comments_count DESC',
         :limit => limit
         )
-    end    
-    
+    end
+
     def new_from_bookmarklet(params)
       self.new(
         :title => "#{params[:title] || params[:uri]}",
         :raw_post => "<a href='#{params[:uri]}'>#{params[:uri]}</a>#{params[:selection] ? "<p>#{params[:selection]}</p>" : ''}"
         )
     end
-  
+
   end
-  
-  
 
-  
+
+
+
   def to_param
     id.to_s << "-" << (title ? title.parameterize : '' )
   end
-  
+
   def display_title
     t = self.title
     if self.category
@@ -109,62 +109,62 @@ class Post < ActiveRecord::Base
     end
     t
   end
-  
+
   def previous_post
     self.user.posts.order('published_at DESC').where('published_at < ? and published_as = ?', published_at, 'live').first
   end
   def next_post
-    self.user.posts.except(:order).order('published_at DESC').where('published_at > ? and published_as = ?', published_at, 'live').first    
+    self.user.posts.except(:order).order('published_at DESC').where('published_at > ? and published_as = ?', published_at, 'live').first
   end
-  
+
   def first_image_in_body(size = nil, options = {})
     doc = Hpricot( post )
     image = doc.at("img")
     image ? image['src'] : nil
   end
-  
+
   def tag_for_first_image_in_body
     image = first_image_in_body
     image.nil? ? '' : "<img src='#{image}' />"
   end
-  
+
   ## transform the text and title into valid html
   def transform_post
    self.post  = white_list(self.raw_post)
    self.title = white_list(self.title)
   end
-  
+
   def set_published_at
     if self.is_live? && !self.published_at
       self.published_at = Time.now
     end
   end
-  
+
   def owner
     self.user
   end
-  
+
   def send_to(email_addresses = '', message = '', user = nil)
     self.invalid_emails = []
     emails = email_addresses.split(",").collect{|email| email.strip }.uniq
-    emails.each do |email|      
+    emails.each do |email|
       self.invalid_emails << email unless email =~ /[\w._%-]+@[\w.-]+.[a-zA-Z]{2,4}/
     end
     if email_addresses.blank? || !invalid_emails.empty?
       return false
-    else    
-      emails = email_addresses.split(",").collect{|email| email.strip }.uniq 
+    else
+      emails = email_addresses.split(",").collect{|email| email.strip }.uniq
       emails.each{|email|
         UserNotifier.post_recommendation((user ? user.login : 'Someone'), email, self, message, user).deliver
       }
-      self.increment(:emailed_count).save    
+      self.increment(:emailed_count).save
     end
   end
-    
+
   def image_for_excerpt
-    first_image_in_body || user.avatar_photo_url(:medium)  
+    first_image_in_body || user.avatar_photo_url(:medium)
   end
-  
+
   def create_poll(poll, choices)
     new_poll = self.polls.new(:question => poll[:question])
     choices.delete('')
@@ -173,7 +173,7 @@ class Post < ActiveRecord::Base
       new_poll.add_choices(choices)
     end
   end
-  
+
   def update_poll(poll, choices)
     return unless self.poll
     self.poll.update_attributes(:question => poll[:question])
@@ -186,18 +186,18 @@ class Post < ActiveRecord::Base
       self.poll.destroy
     end
   end
-  
+
   def poll
     !polls.empty? && polls.first
   end
-  
+
   def has_been_favorited_by(user = nil, remote_ip = nil)
     f = Favorite.find_by_user_or_ip_address(self, user, remote_ip)
     return f
-  end  
-  
+  end
+
   def published_at_display(format = :published_date)
     is_live? ? I18n.l(published_at, :format => format.to_sym) : 'Draft'
   end
-      
+
 end

data/app/models/sb_post.rb

@@ -24,7 +24,7 @@ class SbPost < ActiveRecord::Base
 
   validates_presence_of :body, :topic
   
-  attr_accessible :body, :author_email, :author_ip, :author_name, :author_url
+  attr_accessible :body, :author_email, :author_ip, :author_name, :author_url, :topic, :user_id
   after_create :monitor_topic
   after_create :notify_monitoring_users  
   

data/app/models/topic.rb

@@ -17,8 +17,8 @@ class Topic < ActiveRecord::Base
   after_create  :create_monitorship_for_owner
   
   accepts_nested_attributes_for :sb_posts
-  attr_accessible :title, :sticky, :locked, :sb_posts_attributes, :forum_id
-  
+  attr_accessible :title, :sticky, :locked, :sb_posts_attributes, :forum_id, :user_id
+
   scope :recently_replied, order('replied_at DESC')
 
   def notify_of_new_post(post)