community_engine 2.0.0.beta1

data/app/models/comment.rb

@@ -0,0 +1,122 @@
+class Comment < ActiveRecord::Base
+  include ActsAsCommentable::Comment
+  include Rakismet::Model
+  rakismet_attrs :author => :author_name, :comment_type => 'comment', :content => :comment, :user_ip => :author_ip  
+  attr_protected :akismet_attrs    
+  
+  belongs_to :commentable, :polymorphic => true
+  belongs_to :user, :inverse_of => :comments_as_author, :foreign_key => 'user_id', :class_name => "User"
+  belongs_to :recipient, :class_name => "User", :foreign_key => "recipient_id"
+  
+  validates_presence_of :comment
+  validates_presence_of :commentable_id, :commentable_type
+  validates_length_of :comment, :maximum => 2000
+  
+  before_save :whitelist_attributes  
+  
+  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
+  validates_presence_of :author_ip, :unless => Proc.new{|record| record.user} #log ip unless logged in
+  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
+  
+  def self.find_photo_comments_for(user)
+    Comment.find(:all, :conditions => ["recipient_id = ? AND commentable_type = ?", user.id, 'Photo'], :order => 'created_at DESC')
+  end
+      
+  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)
+  end    
+    
+  def commentable_name
+    type = self.commentable_type.underscore
+    case type
+      when 'user'
+        commentable.login
+      when 'post'
+        commentable.title
+      when 'clipping'
+        commentable.description || "Clipping from #{commentable.user.login}"
+      when 'photo'
+        commentable.description || "Photo from #{commentable.user.login}"
+      else 
+        commentable.class.to_s.humanize
+    end
+  end
+  
+  def title_for_rss
+    "Comment from #{username}"
+  end
+  
+  def username
+    user ? user.login : (author_name.blank? ? 'Anonymous' : author_name)
+  end
+  
+  def self.find_recent(options = {:limit => 5})
+    find(:all, :conditions => "created_at > '#{14.days.ago.iso8601}'", :order => "created_at DESC", :limit => options[:limit])
+  end
+  
+  def can_be_deleted_by(person)
+    person && (person.admin? || person.id.eql?(user_id) || person.id.eql?(recipient_id) )
+  end
+  
+  def should_notify_recipient?
+    return unless recipient && recipient.email
+    return false if recipient.eql?(user)
+    return false unless recipient.notify_comments?
+    true    
+  end
+  
+  def notify_previous_commenters
+    previous_commenters_to_notify.each do |commenter|
+      UserNotifier.follow_up_comment_notice(commenter, self).deliver if commenter.email
+    end    
+  end
+  
+  def notify_previous_anonymous_commenters
+    anonymous_commenters_emails = commentable.comments.map{|c|  c.author_email if (c.notify_by_email? && !c.user && !c.author_email.eql?(self.author_email) && c.author_email) }.uniq.compact
+    anonymous_commenters_emails.each do |email|
+      UserNotifier.follow_up_comment_notice_anonymous(email, self).deliver
+    end    
+  end  
+  
+  def send_notifications
+    return if commentable.respond_to?(:send_comment_notifications?) && !commentable.send_comment_notifications?    
+    UserNotifier.comment_notice(self).deliver if should_notify_recipient?
+    self.notify_previous_commenters
+    self.notify_previous_anonymous_commenters if configatron.allow_anonymous_commenting
+  end
+  
+  def token_for(email)
+    Digest::SHA1.hexdigest("#{id}--#{email}--#{created_at}")                
+  end
+  
+  def unsubscribe_notifications(email)
+    commentable.comments.find_all_by_author_email(email).each do |previous_comment|
+      previous_comment.update_attribute :notify_by_email, false
+    end
+  end
+  
+  def check_spam
+    if !configatron.akismet_key.nil? && self.spam?
+      self.errors.add(:base, :comment_spam_error.l) 
+    end
+  end  
+  
+  
+  protected
+  def whitelist_attributes
+    self.comment = white_list(self.comment)
+  end
+  
+  
+end

data/app/models/country.rb

@@ -0,0 +1,24 @@
+class Country < ActiveRecord::Base
+  has_many :metro_areas
+  
+  def self.get(name)
+    case name
+      when :us
+        c = 'United States'
+    end
+    self.find_by_name(c)
+  end
+  
+  def self.find_countries_with_metros
+    Country.joins(:metro_areas).where('metro_areas.id IS NOT NULL').order('countries.name ASC').all.uniq
+  end
+  
+  def states
+    State.joins(:metro_areas).where("metro_areas.id in (?)", metro_area_ids ).order('states.name ASC').all.uniq
+  end
+  
+  def metro_area_ids
+    metro_areas.map{|m| m.id }.to_ary
+  end
+  
+end

data/app/models/event.rb

@@ -0,0 +1,61 @@
+class Event < ActiveRecord::Base
+  acts_as_activity :user
+  validates_presence_of :name
+  validates_presence_of :start_time
+  validates_presence_of :end_time
+  validates_presence_of :user
+  validate :start_time_cannot_be_before_end_time
+
+  belongs_to :user
+  belongs_to :metro_area
+  has_many :rsvps, :dependent=>:destroy
+  has_many :attendees, :source=>:user, :through=>:rsvps
+
+  attr_protected :user_id
+  
+  #Procs used to make sure time is calculated at runtime
+  scope :upcoming, lambda { 
+    where('end_time > ?' , Time.now).order('start_time ASC')
+  }
+  scope :past, lambda { 
+    where('end_time <= ?' , Time.now).order('start_time DESC')
+  }  
+  
+  
+  acts_as_commentable
+
+  # Used by acts_as_commentable
+  def owner
+    self.user
+  end    
+  
+  def rsvped?(user)
+    self.rsvps.find_by_user_id(user)
+  end
+
+  def attendees_for_user(user)
+    self.rsvps.find_by_user_id(user).attendees_count
+  end
+
+  def attendees_count
+    self.rsvps.sum(:attendees_count)
+  end
+
+  def time_and_date
+    if spans_days?
+      string = "#{start_time.strftime("%B %d")} to #{end_time.strftime("%B %d %Y")}"
+    else
+      string = "#{start_time.strftime("%B %d, %Y")}, #{start_time.strftime("%I:%M %p")} - #{end_time.strftime("%I:%M %p")}"
+    end
+  end
+
+  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

data/app/models/facebook_profile.rb

@@ -0,0 +1,32 @@
+module FacebookProfile
+  def self.included(base)
+    base.class_eval do
+      include InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+    
+    def fb_friend_ids
+      graph.get_connections('/me', 'friends').map{|h| h['id'].to_i}      
+    end
+    
+    def fb_friends_with?(user)
+      fb_friend_ids.include?(user.profile[:id])
+    end
+    
+    def graph
+      @graph ||= Koala::Facebook::API.new(facebook_authorization.token)
+    end
+        
+    def facebook?
+      facebook_authorization
+    end    
+    
+    def facebook_authorization
+      self.authorizations.where(:provider => "facebook").first
+    end
+    
+  end
+              
+end

data/app/models/facebook_publisher.rb

@@ -0,0 +1,45 @@
+class FacebookPublisher
+  include Rails.application.routes.url_helpers
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::SanitizeHelper
+  extend  ActionView::Helpers::SanitizeHelper::ClassMethods
+  
+
+  def self.connected(user)
+    text = "I joined #{configatron.community_name}."    
+    if user.friends_ids.any?
+      text += " There are #{pluralize user.friends_ids.size,'friends'} in my network."
+    else
+      text += " Want to join me?"
+    end
+
+    href = home_url
+
+    user.graph.put_wall_post(text, :link => href, :name => configatron.community_name )
+  end
+  
+  def self.comment_created_hash(comment, url)
+    {
+      :method => 'feed',
+      :link => url,
+      :name => "I left a comment on #{configatron.community_name}",
+      :description => comment
+    }.to_json
+  end
+    
+  def self.blog_post_created_hash(post)
+    hash = {
+      :method => "feed",
+      :name => post.title,
+      :description => strip_tags(post.post),
+      :link => user_post_url(post.user, post, :host => default_host),
+    }
+    hash[:picture] = post.first_image_in_body unless post.first_image_in_body.nil?
+    hash.to_json
+  end
+    
+  def self.default_host
+    configatron.app_host
+  end
+    
+end

data/app/models/favorite.rb

@@ -0,0 +1,47 @@
+class Favorite < ActiveRecord::Base
+  acts_as_activity :user
+  belongs_to :favoritable, :polymorphic => true
+  belongs_to :user
+  
+  validates_presence_of :favoritable
+  
+  validates_presence_of :ip_address
+  
+  after_save :update_counter_on_favoritable
+  after_destroy :update_counter_on_favoritable
+  
+  validates_uniqueness_of :user_id, :scope => [:favoritable_type, :favoritable_id], :allow_nil => true, :message => 'has already favorited this item.'
+  validates_uniqueness_of :ip_address, :scope => [:favoritable_type, :favoritable_id], :message => 'has already favorited this item.', :if => Proc.new{|f| f.user.nil? }
+  
+  #named scopes
+  scope :recent, :order => "created_at DESC"
+  scope :by_user, lambda { |user|
+    {:conditions => ["user_id = ?", user.id] }
+  }
+
+  
+  def update_counter_on_favoritable
+    if favoritable && favoritable.respond_to?(:favorited_count)
+      favoritable.update_attribute(:favorited_count, favoritable.favorites.count.to_s )
+    end
+  end
+  
+  def self.find_favorites_by_user(user)
+    find(:all,
+      :conditions => ["user_id = ?", user.id],
+      :order => "created_at DESC"
+    )
+  end
+  
+  def self.find_by_user_or_ip_address(favoritable = nil, user = nil, remote_ip = nil)
+    return false unless favoritable && (user || remote_ip)
+    
+    if user
+      favorite = self.find(:first, :conditions => ["user_id = ? AND favoritable_type = ? AND favoritable_id = ?", user.id, favoritable.class.to_s, favoritable.id])
+    else
+      favorite = self.find(:first, :conditions => ["ip_address = ? AND favoritable_type = ? AND favoritable_id = ?", remote_ip, favoritable.class.to_s, favoritable.id])      
+    end
+    return favorite
+  end
+
+end

data/app/models/forum.rb

@@ -0,0 +1,22 @@
+class Forum < ActiveRecord::Base
+  acts_as_taggable
+  acts_as_list
+
+  validates_presence_of :name
+
+  has_many :moderatorships, :dependent => :destroy
+  has_many :moderators, :through => :moderatorships, :source => :user
+
+  has_many :topics, :dependent => :destroy
+
+  has_many :sb_posts
+
+  belongs_to :owner, :polymorphic => true
+
+  format_attribute :description
+  
+  def to_param
+    id.to_s << "-" << (name ? name.parameterize : '' )
+  end
+  
+end

data/app/models/friendship.rb

@@ -0,0 +1,64 @@
+class Friendship < ActiveRecord::Base
+
+  @@daily_request_limit = 12
+  cattr_accessor :daily_request_limit
+
+  belongs_to :user
+  belongs_to :friend, :class_name => "User", :foreign_key => "friend_id"   
+  has_enumerated :friendship_status, :class_name => 'FriendshipStatus', :foreign_key => 'friendship_status_id'
+
+  validates_presence_of   :friendship_status
+  validates_presence_of   :user
+  validates_presence_of   :friend
+  validates_uniqueness_of :friend_id, :scope => :user_id
+  validate :cannot_request_if_daily_limit_reached
+  validates_each :user_id do |record, attr, value|
+    record.errors.add attr, 'can not be same as friend' if record.user_id.eql?(record.friend_id)
+  end
+  
+  # named scopes
+  scope :accepted, lambda {
+    #hack: prevents FriendshipStatus[:accepted] from getting called before the friendship_status records are in the db (only matters in testing ENV)
+    {:conditions => ["friendship_status_id = ?", FriendshipStatus[:accepted].id]    }
+  }
+  
+  def cannot_request_if_daily_limit_reached  
+    if new_record? && initiator && user.has_reached_daily_friend_request_limit?
+      errors.add(:base, "Sorry, you'll have to wait a little while before requesting any more friendships.") 
+    end
+  end  
+    
+  before_validation(:on => :create){:set_pending}
+  after_save :notify_requester, :if => Proc.new{|fr| fr.accepted? && fr.initiator }
+
+  attr_protected :friendship_status_id
+  
+  def reverse
+    Friendship.find(:first, :conditions => ['user_id = ? and friend_id = ?', self.friend_id, self.user_id])
+  end
+
+  def denied?
+    friendship_status.eql?(FriendshipStatus[:denied])
+  end
+  
+  def pending?
+    friendship_status.eql?(FriendshipStatus[:pending])
+  end
+  
+  def accepted?
+    friendship_status.eql?(FriendshipStatus[:accepted])    
+  end
+  
+  def self.friends?(user, friend)
+    find(:first, :conditions => ["user_id = ? AND friend_id = ? AND friendship_status_id = ?", user.id, friend.id, FriendshipStatus[:accepted].id ])
+  end
+  
+  def notify_requester
+    UserNotifier.friendship_accepted(self).deliver
+  end
+    
+  private
+  def set_pending
+    friendship_status_id = FriendshipStatus[:pending].id
+  end  
+end

data/app/models/friendship_status.rb

@@ -0,0 +1,3 @@
+class FriendshipStatus < ActiveRecord::Base
+  acts_as_enumerated
+end

data/app/models/homepage_feature.rb

@@ -0,0 +1,15 @@
+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
+  
+  attr_accessible :url, :title, :description, :image
+
+  validates_presence_of :url
+  
+  def self.find_features
+    find(:all, :order => "created_at DESC")
+  end
+
+end

data/app/models/invitation.rb

@@ -0,0 +1,36 @@
+class Invitation < ActiveRecord::Base
+  acts_as_activity :user
+  
+  belongs_to :user
+  
+  after_save :send_invite
+
+  validates_presence_of :user
+  validates_presence_of :email_addresses
+  validates_length_of :email_addresses, :minimum => 6
+  validates_length_of :email_addresses, :maximum => 1500
+
+  validates_each :email_addresses do |record, attr, email_addresses |
+    invalid_emails = []
+    email_addresses = email_addresses || ''
+    emails = email_addresses.split(",").collect{|email| email.strip }.uniq
+    
+    emails.each{ |email|
+      unless email =~ /[\w._%-]+@[\w.-]+.[a-zA-Z]{2,4}/
+        invalid_emails << email
+      end        
+    }
+    unless invalid_emails.empty?
+      record.errors.add(:email_addresses, " included invalid addresses: <ul>"+invalid_emails.collect{|email| '<li>'+email+'</li>' }.join+"</ul>")
+      record.email_addresses = (emails - invalid_emails).join(', ')
+    end
+  end
+  
+  def send_invite
+    emails = self.email_addresses.split(",").collect{|email| email.strip }.uniq 
+    emails.each{|email|
+      UserNotifier.signup_invitation(email, self.user, self.message).deliver
+    }
+  end
+  
+end

data/app/models/message.rb

@@ -0,0 +1,84 @@
+class Message < ActiveRecord::Base  
+  attr_accessor :to
+  attr_accessor :reply_to
+  
+  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
+
+  belongs_to :parent, :class_name => "Message", :foreign_key => "parent_id", :inverse_of => :children
+  has_many :children, :class_name => "Message", :foreign_key => "parent_id", :inverse_of => :parent
+  has_many :message_threads
+  
+  scope :parent_messages, where("parent_id IS NULL")
+  scope :already_read, where("read_at IS NOT NULL")
+  scope :unread, where("read_at IS NULL")
+  
+  validates_presence_of :body, :subject
+  validates_presence_of :recipient, :message => "is invalid"
+  validate :ensure_not_sending_to_self
+  
+  after_create :notify_recipient
+  after_create :update_message_threads
+  
+  
+  # Ensures the passed user is either the sender or the recipient then returns the message.
+  # If the reader is the recipient and the message has yet not been read, it marks the read_at timestamp.
+  def self.read(id, reader)
+    message = find(id, :conditions => ["sender_id = ? OR recipient_id = ?", reader, reader])
+    if message.read_at.nil? && reader == message.recipient
+      message.read_at = Time.now
+      message.save!
+    end
+    message
+  end
+  
+  # Returns true or false value based on whether the a message has been read by its recipient.
+  def read?
+    self.read_at.nil? ? false : true
+  end
+  
+  # Marks a message as deleted by either the sender or the recipient, which ever the user that was passed is.
+  # Once both have marked it deleted, it is destroyed.
+  def mark_deleted(user)
+    self.sender_deleted = true if self.sender == user
+    self.recipient_deleted = true if self.recipient == user
+    self.sender_deleted && self.recipient_deleted ? self.destroy : save!
+  end
+  
+  
+  def ensure_not_sending_to_self
+    errors.add(:base, "You may not send a message to yourself.") if self.recipient && self.recipient.eql?(self.sender)    
+  end
+  
+  def notify_recipient
+    UserNotifier.message_notification(self).deliver
+  end
+  
+  def update_message_threads
+    recipients_thread = MessageThread.find_or_create_by_recipient_id_and_parent_message_id(self.recipient_id, (self.parent_id || self.id))
+    recipients_thread.attributes = {:sender => sender, :recipient => recipient, :message => self, :parent_message => (self.parent || self)}
+    recipients_thread.save
+    
+    if parent
+      senders_thread = MessageThread.find_or_create_by_recipient_id_and_parent_message_id(self.sender_id, self.parent_id)
+      senders_thread.message = self
+      senders_thread.save
+    end
+  end
+  
+  def self.new_reply(sender, message_thread = nil, params = {})
+    message = new(params[:message])
+    message.to ||= params[:to] if params[:to]
+  
+    if message_thread
+      message.parent = message_thread.parent_message
+      message.reply_to = message_thread.message
+      message.to = message_thread.sender.login
+      message.subject = message_thread.parent_message.subject
+      message.sender = sender
+    end
+  
+    message
+  end
+    
+end

data/app/models/message_thread.rb

@@ -0,0 +1,33 @@
+class MessageThread < ActiveRecord::Base
+  belongs_to :message
+  belongs_to :parent_message, :class_name => 'Message'
+  belongs_to :sender, :class_name => 'User', :foreign_key => "sender_id"
+  belongs_to :recipient, :class_name => 'User', :foreign_key => "recipient_id"
+  
+  before_destroy :mark_messages_deleted
+  
+  def subject
+    parent_message.subject
+  end
+  
+  def creator_name
+    parent_message.sender.eql?(recipient) ? 'Me' : parent_message.sender.login
+  end
+  
+  def self.for(message, user)
+    find(:first, :conditions => {:parent_message_id => (message.parent_id || message.id), :recipient_id => user.id})
+  end
+  
+  def mark_messages_deleted
+    parent_message.mark_deleted(recipient)
+    parent_message.children.each do |child|
+      child.mark_deleted(recipient)
+    end
+  end
+  
+  def read?
+    message.recipient.eql?(recipient) ? message.read? : 'read'
+  end
+  
+  
+end

data/app/models/metro_area.rb

@@ -0,0 +1,16 @@
+class MetroArea < ActiveRecord::Base
+  has_many :users
+  belongs_to :state
+  belongs_to :country
+
+  #validates_presence_of :state, :if => Proc.new { |user| user.country.eql?(Country.get(:us)) }
+  validates_presence_of :country_id
+  validates_presence_of :name
+
+	acts_as_commentable
+
+  def to_s
+    name
+  end
+
+end

data/app/models/moderatorship.rb

@@ -0,0 +1,8 @@
+class Moderatorship < ActiveRecord::Base
+  belongs_to :forum
+  belongs_to :user
+  validates_presence_of :user, :forum
+
+  validates_uniqueness_of :user_id, :scope => :forum_id
+
+end

data/app/models/monitorship.rb

@@ -0,0 +1,6 @@
+class Monitorship < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :topic
+  validates_presence_of :user, :topic
+  validates_uniqueness_of :user_id, :scope => :topic_id
+end

data/app/models/page.rb

@@ -0,0 +1,8 @@
+class Page < ActiveRecord::Base
+  acts_as_publishable :live, :draft, :members_only, :public
+  validates_presence_of :title, :body
+  
+  def to_param
+    id.to_s << "-" << (title ? title.parameterize : '')
+  end
+end