community_engine 2.0.0.beta1

data/app/models/photo.rb

@@ -0,0 +1,83 @@
+class Photo < ActiveRecord::Base
+  acts_as_commentable
+  belongs_to :album
+  
+  has_attached_file :photo, configatron.photo.paperclip_options.to_hash
+  validates_attachment_presence :photo
+  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
+
+  attr_accessor :crop_x, :crop_y, :crop_w, :crop_h
+  after_update :reprocess_photo, :if => :cropping?
+  
+  acts_as_taggable
+
+  acts_as_activity :user, :if => Proc.new{|record| record.album_id.nil?}
+  
+  validates_presence_of :user
+  
+  belongs_to :user
+  has_one :user_as_avatar, :class_name => "User", :foreign_key => "avatar_id", :inverse_of => :avatar
+  
+  #Named scopes
+  scope :recent, :order => "photos.created_at DESC"
+  scope :new_this_week, :order => "photos.created_at DESC", :conditions => ["photos.created_at > ?", 7.days.ago.iso8601]
+  attr_accessible :name, :description, :photo, :crop_x, :crop_y, :crop_w, :crop_h, :user_id
+
+  def display_name
+    (self.name && self.name.length>0) ? self.name : "#{:created_at.l.downcase}: #{I18n.l(self.created_at, :format => :published_date)}"
+  end
+
+  def description_for_rss
+    "<a href='#{self.link_for_rss}' title='#{self.name}'><img src='#{self.photo.url(:large)}' alt='#{self.name}' /><br />#{self.description}</a>"
+  end
+
+  def owner
+    self.user
+  end
+
+  def previous_photo
+    self.user.photos.find(:first, :conditions => ['created_at < ?', created_at], :order => 'created_at DESC')
+  end
+  def next_photo
+    self.user.photos.find(:first, :conditions => ['created_at > ?', created_at], :order => 'created_at ASC')
+  end
+
+  def previous_in_album
+    return nil unless self.album
+    self.user.photos.find(:first, :conditions => ['created_at < ? and album_id = ?', created_at, self.album.id], :order => 'created_at DESC')
+  end
+  def next_in_album
+    return nil unless self.album    
+    self.user.photos.find(:first, :conditions => ['created_at > ? and album_id = ?', created_at, self.album_id], :order => 'created_at ASC')
+  end
+
+
+  def self.find_recent(options = {:limit => 3})
+    self.new_this_week.find(:all, :limit => options[:limit])
+  end
+  
+  def self.find_related_to(photo, options = {})
+    options.reverse_merge!({:limit => 8, 
+        :order => 'created_at DESC', 
+        :conditions => ['photos.id != ?', photo.id]
+    })
+    limit(options[:limit]).order(options[:order]).where(options[:conditions]).tagged_with(photo.tags.collect{|t| t.name })
+  end
+
+  def cropping?
+    !crop_x.blank? && !crop_y.blank? && !crop_w.blank? && !crop_h.blank?
+  end
+
+  def photo_geometry(style = :original)
+    @geometry ||= {}
+    @geometry[style] ||= Paperclip::Geometry.from_file(photo.path(style))
+  end
+
+  private
+
+  def reprocess_photo
+    photo.reprocess!
+  end
+
+end

data/app/models/poll.rb

@@ -0,0 +1,39 @@
+class Poll < ActiveRecord::Base
+  has_many :choices, :dependent => :destroy
+  validates_presence_of :question
+  validates_presence_of :post
+  has_many :votes, :dependent => :destroy
+  belongs_to :post
+      
+  def voted?(user)
+    !self.votes.find_by_user_id(user.id).nil?
+  end
+  
+  def add_choices(choices)
+    choices.each do |description|
+      choice = self.choices.new(:description => description)
+      choice.save
+    end
+  end
+
+  def self.find_recent(options = {})
+    options.reverse_merge! :limit => 5
+    find(:all, :order => "polls.created_at desc", :limit => options[:limit], :include => [:post => :user])
+  end
+
+  def self.find_popular(options = {})
+    options.reverse_merge! :limit => 5, :since => 10.days.ago
+    
+    find(:all, :order => "polls.votes_count desc", 
+      :limit => options[:limit], 
+      :include => [:post => :user],
+      :conditions => ["polls.created_at > ?", options[:since]]
+    )
+  end
+
+  def self.find_popular_in_category(category, options = {})
+    options.reverse_merge! :limit => 5
+    self.includes(:post).order('polls.votes_count desc').limit(options[:limit]).where('posts.category_id = ?', category.id)
+  end
+
+end

data/app/models/post.rb

@@ -0,0 +1,201 @@
+class Post < ActiveRecord::Base
+  include Rakismet::Model
+  rakismet_attrs :comment_type => 'post'
+  attr_protected :akismet_attrs  
+  
+  
+  acts_as_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
+  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 
+    elsif post.is_draft? && activity
+      activity.destroy
+    end
+  end
+    
+  attr_accessor :invalid_emails
+  
+  # Class Methods
+  class << self
+    
+    # Scopes    
+    def by_featured_writers
+      where("users.featured_writer = ?", true).includes(:user)
+    end
+    def popular
+      order('posts.view_count DESC')
+    end
+    def since(days)
+      where("posts.published_at > ?", days.ago)    
+    end
+    def recent
+      order("posts.published_at DESC")    
+    end
+  
+    def find_related_to(post, options = {})
+      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)
+    end
+    
+    def find_recent(options = {:limit => 5})
+      recent.find :all, options
+    end
+
+    def find_popular(options = {} )
+      options.reverse_merge! :limit => 5, :since => 7.days
+
+      self.popular.since(options[:since]).limit(options[:limit]).all
+    end
+
+    def find_featured(options = {:limit => 10})
+      self.recent.by_featured_writers.limit(options[:limit]).all
+    end
+
+    def find_most_commented(limit = 10, since = 7.days.ago)
+      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],
+        :group => self.columns.map{|column| self.table_name + "." + column.name}.join(","),
+        :order => 'comments_count DESC',
+        :limit => limit
+        )
+    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
+      t = self.category.name.upcase << ": " << t
+    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    
+  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|      
+      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 
+      emails.each{|email|
+        UserNotifier.post_recommendation((user ? user.login : 'Someone'), email, self, message, user).deliver
+      }
+      self.increment(:emailed_count).save    
+    end
+  end
+    
+  def image_for_excerpt
+    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('')
+    if choices.size > 1
+      new_poll.save
+      new_poll.add_choices(choices)
+    end
+  end
+  
+  def update_poll(poll, choices)
+    return unless self.poll
+    self.poll.update_attributes(:question => poll[:question])
+    choices.delete('')
+    if choices.size > 1
+      self.poll.choices.destroy_all
+      self.poll.save
+      self.poll.add_choices(choices)
+    else
+      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  
+  
+  def published_at_display(format = :published_date)
+    is_live? ? I18n.l(published_at, :format => format.to_sym) : 'Draft'
+  end
+      
+end

data/app/models/role.rb

@@ -0,0 +1,5 @@
+class Role < ActiveRecord::Base
+  acts_as_enumerated
+  validates_presence_of :name  
+end
+

data/app/models/rsvp.rb

@@ -0,0 +1,24 @@
+class Rsvp < ActiveRecord::Base
+  acts_as_activity :user
+  validates_numericality_of :attendees_count, :only_integer=>true, :greater_than=>0
+  validates_presence_of :event, :user
+  validates_uniqueness_of :user_id, :scope => :event_id, :message => I18n.t(:you_have_already_rsvped_for_this_event)
+  validate :event_in_future
+  validate :event_allows_rsvp
+
+  belongs_to :user
+  belongs_to :event
+
+  attr_protected :user_id
+  attr_protected :event_id
+
+private
+
+  def event_allows_rsvp
+    errors.add(:base, :event_does_not_allow_rsvp.l) unless self.event.allow_rsvp?
+  end
+
+  def event_in_future
+    errors.add(:base, :cannot_rsvp_for_an_event_that_has_already_happened.l) if self.event.end_time < Time.now
+  end
+end

data/app/models/sb_post.rb

@@ -0,0 +1,67 @@
+class SbPost < ActiveRecord::Base
+  acts_as_activity :user, :if => Proc.new{|record| record.user } #don't record an activity if there's no user  
+  include Rakismet::Model
+  rakismet_attrs :author => :username, :comment_type => 'comment', :content => :body, :user_ip => :author_ip
+  
+  belongs_to :forum, :counter_cache => true
+  belongs_to :user,  :counter_cache => true
+  belongs_to :topic, :counter_cache => true
+
+  format_attribute :body
+  before_create { |r| r.forum_id = r.topic.forum_id }
+  after_create  { |r| 
+    Topic.update_all(['replied_at = ?, replied_by = ?, last_post_id = ?', r.created_at, r.user_id, r.id], ['id = ?', r.topic_id]) 
+  }
+  after_destroy { |r| 
+    t = Topic.find(r.topic_id)
+    Topic.update_all(['replied_at = ?, replied_by = ?, last_post_id = ?', t.sb_posts.recent.last.created_at, t.sb_posts.recent.last.user_id, t.sb_posts.recent.last.id], ['id = ?', t.id]) if t.sb_posts.recent.last 
+  }
+
+  validates_presence_of :user_id, :unless => Proc.new{|record| configatron.allow_anonymous_forum_posting }
+  validates_presence_of :author_email, :unless => Proc.new{|record| record.user }  #require email unless logged in
+  validates_format_of :author_email, :with => /^([^@\s]+)@((?:[-a-z0-9A-Z]+\.)+[a-zA-Z]{2,})$/, :unless => Proc.new{|record| record.user}
+  validates_presence_of :author_ip, :unless => Proc.new{|record| record.user} #log ip unless logged in
+
+  validates_presence_of :body, :topic
+  
+  attr_accessible :body, :author_email, :author_ip, :author_name, :author_url
+  after_create :monitor_topic
+  after_create :notify_monitoring_users  
+  
+  scope :with_query_options, :select => 'sb_posts.*, topics.title as topic_title, forums.name as forum_name', :joins => 'inner join topics on sb_posts.topic_id = topics.id inner join forums on topics.forum_id = forums.id', :order => 'sb_posts.created_at desc'
+  scope :recent, :order => 'sb_posts.created_at ASC'
+  validate :check_spam    
+    
+  def monitor_topic
+    return unless user    
+    monitorship = Monitorship.find_or_initialize_by_user_id_and_topic_id(self.user.id, self.topic.id)
+    if monitorship.new_record?
+      monitorship.update_attribute :active, true
+    end
+  end
+  
+  def notify_monitoring_users
+    topic.notify_of_new_post(self)
+  end
+  
+  def editable_by?(user)
+    user && (user.id == user_id || user.admin? || user.moderator_of?(topic.forum_id))
+  end
+  
+  def to_xml(options = {})
+    options[:except] ||= []
+    options[:except] << :topic_title << :forum_name
+    super
+  end
+  
+  def username
+    user ? user.login : (author_name.blank? ? :anonymous.l : author_name)
+  end
+  
+  def check_spam
+    if !configatron.akismet_key.nil? && self.spam?
+      self.errors.add(:base, :comment_spam_error.l) 
+    end
+  end  
+  
+end

data/app/models/state.rb

@@ -0,0 +1,4 @@
+class State < ActiveRecord::Base
+  has_many :metro_areas
+  # belongs_to :country
+end

data/app/models/topic.rb

@@ -0,0 +1,72 @@
+class Topic < ActiveRecord::Base
+  acts_as_activity :user
+  
+  acts_as_taggable
+  belongs_to :forum, :counter_cache => true
+  belongs_to :user
+  has_many :monitorships
+  has_many :monitors, :through => :monitorships, :conditions => ['monitorships.active = ?', true], :source => :user
+
+  has_many :sb_posts, :dependent => :destroy
+
+  belongs_to :replied_by_user, :foreign_key => "replied_by", :class_name => "User"
+  
+  validates_presence_of :forum, :user, :title
+  before_create :set_default_replied_at_and_sticky
+  after_save    :set_post_topic_id
+  after_create  :create_monitorship_for_owner
+
+  attr_accessible :title
+  # to help with the create form
+  attr_accessor :body
+  
+  scope :recently_replied, order('replied_at DESC')
+  
+
+  def notify_of_new_post(post)
+    monitorships.each do |m|
+      UserNotifier.new_forum_post_notice(m.user, post).deliver if (m.user != post.user) && m.user.notify_comments
+    end
+  end
+
+  def to_param
+    id.to_s << "-" << (title ? title.parameterize : '' )
+  end
+
+  def voices
+    sb_posts.map { |p| p.user_id }.uniq.size
+  end
+  
+  def hit!
+    self.class.increment_counter :hits, id
+  end
+
+  def sticky?() sticky == 1 end
+
+  def views() hits end
+
+  def paged?() sb_posts_count > 25 end
+  
+  def last_page
+    (sb_posts_count.to_f / 25.0).ceil.to_i
+  end
+
+  def editable_by?(user)
+    user && (user.id == user_id || user.admin? || user.moderator_of?(forum_id))
+  end
+  
+  protected
+    def set_default_replied_at_and_sticky
+      self.replied_at = Time.now.utc
+      self.sticky   ||= 0
+    end
+
+    def set_post_topic_id
+      SbPost.update_all ['forum_id = ?', forum_id], ['topic_id = ?', id]
+    end
+    
+    def create_monitorship_for_owner
+      monitorship = Monitorship.find_or_initialize_by_user_id_and_topic_id(user.id, self.id)
+      monitorship.update_attribute :active, true      
+    end
+end

data/app/models/twitter_profile.rb

@@ -0,0 +1,20 @@
+module TwitterProfile
+  def self.included(base)
+    base.class_eval do
+      include InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+        
+    def twitter?
+      twitter_authorization
+    end    
+    
+    def twitter_authorization
+      self.authorizations.where(:provider => "twitter").first
+    end
+    
+  end
+              
+end