radiant-forum-extension 0.6.0

data/app/controllers/topics_controller.rb

@@ -0,0 +1,78 @@
+class TopicsController < ReaderActionController
+  
+  before_filter :find_forum_and_topic, :except => :index
+  before_filter :require_activated_reader, :except => [:index, :show]
+
+  radiant_layout { |controller| controller.layout_for(:forum) }
+
+  def index
+    params[:per_page] ||= 20
+    @topics = Topic.visible.paginate(:all, :order => "topics.sticky desc, topics.replied_at desc", :page => params[:page] || 1, :per_page => params[:per_page], :include => [:forum, :reader])
+    render_page_or_feed
+  end
+
+  def new
+    @topic = Topic.new
+    @topic.first_post = @topic.posts.build
+    @topic.forum = @forum || Forum.find_by_name(Radiant::Config['forum.default_forum'])
+  end
+  
+  def show
+    if @page && request.format == 'text/html'
+      redirect_to "#{@page.url}#forum"
+      return false
+    end
+    @topic.hit! unless current_reader and @topic.reader == current_reader
+    store_location((request.format == 'text/html') ? request.request_uri : request.referer)
+    
+    params[:per_page] ||= 20
+    params[:page] = 1 if params[:page] == 'first'
+    params[:page] = (@topic.posts.count.to_f / params[:per_page].to_f).ceil if params[:page] == 'last'
+    @posts = Post.paginate_by_topic_id(@topic.id, :page => params[:page], :per_page => params[:per_page], :include => :reader, :order => 'posts.created_at asc')
+    render_page_or_feed(@page ? 'comments' : 'show')
+  end
+  
+  def create
+    # post creation is handled by a before_create in the topic model
+    # and then calls back to set initial reply data in the topic
+    @forum = Forum.find(params[:topic][:forum_id]) if params[:topic][:forum_id]
+    @topic = @forum.topics.create!(params[:topic])
+    @topic.first_post.save_attachments(params[:files]) unless @topic.page && !Radiant::Config['forum.comments_have_attachments']
+    
+    respond_to do |format|
+      format.html { redirect_to forum_topic_path(@forum, @topic) }
+    end
+  rescue ActiveRecord::RecordInvalid => invalid
+    flash[:error] = "Sorry: #{invalid}. Please check the form"
+    respond_to do |format|
+      format.html { render :action => 'new' }
+    end
+  end
+  
+  def update
+    # post update is handled by a before_update in the topic model
+    @topic.attributes = params[:topic]
+    @topic.save!
+    respond_to do |format|
+      format.html { redirect_to forum_topic_path(@forum, @topic) }
+    end
+  end
+  
+  def destroy
+    @topic.destroy
+    flash[:notice] = "Topic '{name}' was deleted."[:topic_deleted_message, CGI::escapeHTML(@topic.name)]
+    respond_to do |format|
+      format.html { redirect_to forum_path(@forum) }
+    end
+  end
+  
+  protected
+
+    def find_forum_and_topic
+      @topic = Topic.find(params[:id]) if params[:id]
+      @page = @topic.page if @topic
+      @forum = @topic.forum if @topic
+      @forum ||= Forum.find(params[:forum_id]) if params[:forum_id]
+    end
+    
+end

data/app/models/forum.rb

@@ -0,0 +1,52 @@
+class Forum < ActiveRecord::Base
+  is_site_scoped if defined? ActiveRecord::SiteNotFound
+  default_scope :order => 'name ASC'
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+  validates_presence_of :name
+  named_scope :visible, {}
+
+  has_many :topics, :order => 'sticky desc, replied_at desc', :dependent => :destroy do
+    def first
+      @first_topic ||= find(:first)
+    end
+  end
+
+  has_many :recent_topics, :class_name => 'Topic', :order => 'replied_at desc' do 
+    def first 
+      @first_recent_topic ||= find(:first) 
+    end 
+    def latest
+      @latest_topics ||= find(:all, :limit => 5)
+    end
+  end
+
+  has_many :posts, :order => 'posts.created_at desc' do
+    def last
+      @last_post ||= find(:first, :include => :reader)
+    end
+    def latest
+      @latest_posts ||= find(:all, :limit => 5)
+    end
+  end
+  
+  def self.find_or_create_comments_forum
+    @comments_forum = self.find_by_for_comments(true) || self.create(
+      :name => 'Page Comments',
+      :description => 'This forum automatically gathers up all comments on pages. You can reply here or on the page.',
+      :created_by => User.find_by_admin(true),
+      :position => 999,
+      :created_at => Time.now,
+      :for_comments => true
+    )
+  end
+  
+  def dom_id
+    "forum_#{self.id}"
+  end
+  
+  def visible_to?(reader=nil)
+    true
+  end
+
+end

data/app/models/moderatorship.rb

@@ -0,0 +1,5 @@
+class Moderatorship < ActiveRecord::Base
+  belongs_to :forum
+  belongs_to :user
+  before_create { |r| count(:all, :conditions => ['forum_id = ? and user_id = ?', r.forum_id, r.user_id]).zero? }
+end

data/app/models/post.rb

@@ -0,0 +1,122 @@
+require 'sanitize'
+class Post < ActiveRecord::Base
+  
+  is_site_scoped if defined? ActiveRecord::SiteNotFound
+  
+  belongs_to :forum, :counter_cache => true
+  belongs_to :reader,  :counter_cache => true
+  belongs_to :topic, :counter_cache => true
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+  has_many :attachments, :class_name => 'PostAttachment', :order => :position, :dependent => :destroy
+  
+  attr_writer :name
+
+  before_validation :set_reader
+  before_create :set_forum
+  after_create :update_topic_reply_data
+  after_destroy :revert_topic_reply_data
+  
+  validates_presence_of :reader, :topic, :body
+
+  named_scope :visible, {}
+  named_scope :latest, lambda { |count|
+    {
+      :order => 'created_at DESC',
+      :limit => count
+    }
+  }
+
+  def topic_page
+    self.topic.page_for(self)
+  end
+  
+  def to_xml(options = {})
+    options[:except] ||= []
+    options[:except] << :topic_title << :forum_name
+    super
+  end
+  
+  def dom_id
+    "post_#{self.id}"
+  end
+  
+  def first?
+    self.topic.first_post == self
+  end
+  
+  def has_replies?
+    self.topic.last_post != self
+  end
+  
+  def is_comment?
+    !self.topic.page.nil?
+  end
+  
+  def page
+    return self.topic.page if is_comment?
+  end
+  
+  def editable_interval
+    Radiant::Config['forum.editable_period'].to_i.minutes if Radiant::Config['forum.editable_period']
+  end
+  
+  def still_editable_for
+    if editable_interval && still_editable?
+      self.created_at + editable_interval - Time.now 
+    else
+      0
+    end
+  end
+  
+  def still_editable?
+    !editable_interval || Time.now - self.created_at < editable_interval
+  end
+  
+  def editable_by?(reader=nil)
+    return false unless reader
+    still_editable? && reader && (reader.id == reader_id)
+  end
+  
+  def visible_to?(reader=nil)
+    topic.forum.visible_to?(reader)
+  end
+
+  # we shouldn't have formatting in here, but page comments need to be rendered from a radius tag
+  
+  def body_html
+    if body
+      html = RedCloth.new(body, [ :hard_breaks, :filter_html ]).to_html(:textile, :smilies)
+      Sanitize.clean(html, Sanitize::Config::RELAXED)
+    else
+      ""
+    end
+  end
+    
+  def date_html
+    self.created_at.to_s
+  end
+  
+  def save_attachments(files=nil)
+    files.collect {|file| self.attachments.create(:file => file) unless file.blank? } if files
+  end
+  
+protected
+
+  def set_reader
+    self.reader ||= Reader.current
+  end
+
+  def set_forum
+    self.forum ||= self.topic.forum
+  end
+  
+  def update_topic_reply_data
+    self.topic.refresh_reply_data(self)
+  end
+
+  def revert_topic_reply_data
+    self.topic.refresh_reply_data
+  end
+  
+end

data/app/models/post_attachment.rb

@@ -0,0 +1,73 @@
+class PostAttachment < ActiveRecord::Base
+
+  @@image_content_types = ['image/jpeg', 'image/pjpeg', 'image/gif', 'image/png', 'image/x-png', 'image/jpg']
+  cattr_reader :image_content_types
+
+  class << self
+    def image?(content_type)
+      image_content_types.include?(content_type)
+    end
+    
+    def thumbnail_sizes
+      if Radiant::Config.table_exists? && Radiant::Config["assets.additional_thumbnails"]
+        thumbnails = Radiant::Config["assets.additional_thumbnails"].split(', ').collect{|s| s.split('=')}.inject({}) {|ha, (k, v)| ha[k.to_sym] = v; ha}
+      else
+        thumbnails = {}
+      end
+      thumbnails.merge({
+        :icon => ['24x24#', :png],
+        :thumbnail => ['100x100>', :png]
+      })
+    end
+    
+    def thumbnail_names
+      thumbnail_sizes.keys
+    end
+  end
+
+  belongs_to :post
+  belongs_to :reader
+  acts_as_list :scope => :post_id
+  has_attached_file :file,
+                    :styles => thumbnail_sizes,
+                    :whiny_thumbnails => false,
+                    :url => "/:class/:id/:basename:no_original_style.:extension",
+                    :path => ":rails_root/public/:class/:id/:basename:no_original_style.:extension"
+
+  attr_protected :file_file_name, :file_content_type, :file_file_size
+  validates_attachment_presence :file, :message => "You must choose a file to upload!"
+  validates_attachment_content_type :file, :content_type => Radiant::Config["forum.attachment_content_types"].split(', ') if Radiant::Config.table_exists? && Radiant::Config["forum.attachment_content_types"]
+  validates_attachment_size :file, :less_than => Radiant::Config["forum.max_attachment_size"].to_i.megabytes if Radiant::Config.table_exists? && Radiant::Config["forum.max_attachment_size"]
+
+  def image?
+    self.class.image?(file_content_type)
+  end
+  
+  def filename
+    file_file_name
+  end
+
+  def basename
+    File.basename(filename, ".*") if filename
+  end
+
+  def extension
+    filename.split('.').last.downcase if filename
+  end
+    
+  def icon
+    iconpath = Radiant::Config.table_exists? && Radiant::Config['forum.icon_path'] ? Radiant::Config['forum.icon_path'] : '/images/forum/icons'
+    if image?
+      return file.url(:icon)
+    else
+      icon = File.join(RAILS_ROOT, 'public', iconpath, "#{extension}.png")
+      logger.warn "!!  looking for #{icon}"
+      if File.exists? icon
+        "#{iconpath}/#{extension}.png"
+      else
+        "#{iconpath}/attachment.png"
+      end
+    end
+  end
+
+end

data/app/models/topic.rb

@@ -0,0 +1,162 @@
+class Topic < ActiveRecord::Base
+  is_site_scoped if defined? ActiveRecord::SiteNotFound
+
+  belongs_to :forum, :counter_cache => true
+  belongs_to :page
+  belongs_to :reader
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+
+  belongs_to :first_post, :class_name => 'Post', :include => :reader                                                # aka topic.body. should not change
+  belongs_to :last_post, :class_name => 'Post', :include => :reader                                                 # this is just for display efficiency.
+  belongs_to :replied_by, :class_name => 'Reader'                                                                   # this too.
+  has_many :posts, :order => 'posts.created_at', :include => :reader, :dependent => :destroy do
+    def last
+      @last_post ||= find(:last)
+    end
+  end
+
+  validates_presence_of :forum, :reader, :name
+  validates_uniqueness_of :old_id, :allow_nil => true
+
+  before_validation :set_reader
+  before_create :set_defaults
+  before_update :check_for_changing_forums
+  before_validation_on_create :post_valid?
+  after_create :save_post
+  before_update :update_post
+  
+  attr_accessor :body
+
+  named_scope :visible, {}
+  named_scope :latest, lambda { |count|
+    {
+      :order => 'replied_at DESC',
+      :limit => count
+    }
+  }
+
+  def voice_count
+    posts.count(:select => "DISTINCT reader_id")
+  end
+  
+  def voices
+    # TODO - move into sql
+    posts.map { |p| p.reader }.uniq
+  end
+    
+  def hit!
+    self.class.increment_counter :hits, id
+  end
+
+  def sticky?() sticky == 1 end
+
+  def views() hits end
+
+  def paged?() posts_count > posts_per_page end
+  
+  def posts_per_page
+    ppp = Radiant::Config['forum.posts_per_page'] || 25
+    ppp.to_i.to_f
+  end
+  
+  def last_page
+    (posts_count.to_f/posts_per_page).ceil.to_i
+  end
+  
+  def page_for(post)
+    return nil unless post.topic == self
+    return 1 unless paged?
+    (posts.index(post)/posts_per_page).ceil.to_i
+  end
+
+  def editable_by?(user)
+    reader && (reader.id == reader_id)
+  end
+  
+  def has_posts?
+    posts_count > (page ? 0 : 1)
+  end
+  
+  def refresh_reply_data(post=nil)
+    if !post && posts.empty?     # ie. the post has just been deleted and there are no others
+      self.destroy
+    elsif has_posts?
+      post ||= posts.last
+      self.last_post = post
+      self.replied_by = post.reader
+      self.replied_at = post.created_at
+      self.save!
+    end
+  end
+  
+  def last_post_with_fetch
+    if lp = last_post_without_fetch
+      lp
+    elsif has_posts? && lp = posts.last
+      update_attribute(:last_post_id, lp.id)
+      lp
+    end
+  end
+  alias_method_chain :last_post, :fetch
+
+  def dom_id
+    "topic_#{self.id}"
+  end
+  
+  def visible_to?(reader=nil)
+    forum.visible_to?(reader)
+  end
+  
+protected
+
+  def set_reader
+    self.reader ||= Reader.current
+  end
+
+  def set_defaults
+    self.sticky ||= 0
+    self.locked ||= 0
+  end
+
+  def check_for_changing_forums
+    old = Topic.find(id)
+    if old.forum_id != forum_id
+      set_posts_forum_id
+      Forum.update_all ["posts_count = posts_count - ?", posts_count], ["id = ?", old.forum_id]
+      Forum.update_all ["posts_count = posts_count + ?", posts_count], ["id = ?", forum_id]
+    end
+  end
+
+  def set_posts_forum_id
+    Post.update_all ['forum_id = ?', forum_id], ['topic_id = ?', id]
+  end
+
+  def post_valid?
+    post = Post.new(:body => self.body, :reader => self.reader, :topic => self)
+    unless post.valid?
+      self.errors.add(:body, post.errors.on(:body))
+      self.errors.add(:reader, post.errors.on(:reader))
+      raise ActiveRecord::RecordInvalid.new(self)
+    end
+    true
+  end
+
+  def save_post
+    self.first_post = self.posts.create!(:body => self.body, :created_at => self.created_at, :reader => self.reader)
+    self.replied_at ||= Time.now();
+    self.save(false)
+  end
+  
+  def update_post
+    post = self.first_post
+    if !self.body.nil? && self.body != post.body
+      post.body = self.body
+      post.save!
+    end
+  rescue ActiveRecord::RecordInvalid => ow
+    self.errors.add(:body, post.errors.on(:body))
+    raise
+  end
+
+end