community_engine 2.0.0.beta1

data/app/controllers/photos_controller.rb

@@ -0,0 +1,189 @@
+  require 'pp'
+
+class PhotosController < BaseController
+  include Viewable  
+  before_filter :login_required, :only => [:new, :edit, :update, :destroy, :create, :swfupload]
+  before_filter :find_user, :only => [:new, :edit, :index, :show]
+  before_filter :require_current_user, :only => [:new, :edit, :update, :destroy]
+
+  skip_before_filter :verify_authenticity_token, :only => [:create] #because the TinyMCE image uploader can't provide the auth token
+
+  uses_tiny_mce do
+    {:only => [:show], :options => configatron.simple_mce_options}
+  end
+
+  cache_sweeper :taggable_sweeper, :only => [:create, :update, :destroy]    
+
+  def recent
+    @photos = Photo.recent.page(params[:page])
+  end
+  
+  def index
+    @user = User.find(params[:user_id])
+
+    @photos = Photo.where(:user_id => @user.id).includes(:tags)
+    if params[:tag_name]
+      @photos = @photos.where('tags.name = ?', params[:tag_name])
+    end
+    
+    @photos = @photos.recent.page(params[:page]).per(20)
+  
+    @tags = Photo.includes(:taggings).where(:user_id => @user.id).tag_counts(:limit => 20)
+  
+    @rss_title = "#{configatron.community_name}: #{@user.login}'s photos"
+    @rss_url = user_photos_path(@user,:format => :rss)
+
+    respond_to do |format|
+      format.html 
+      format.rss {
+        render_rss_feed_for(@photos,
+           { :feed => {:title => @rss_title, :link => url_for(:controller => 'photos', :action => 'index', :user_id => @user) },
+             :item => {:title => :name,
+                       :description => Proc.new {|photo| description_for_rss(photo)},
+                       :link => Proc.new {|photo| user_photo_url(photo.user, photo)},
+                       :pub_date => :created_at} })
+
+      }
+      format.xml { render :action => 'index.rxml', :layout => false}
+    end
+  end
+
+  def manage_photos
+    if logged_in?
+      @user = current_user      
+      @photos = current_user.photos.recent.includes(:tags)      
+      if params[:tag_name]
+        @photos = @photos.where('tags.name = ?', params[:tag_name])
+      end
+      @selected = params[:photo_id]
+      @photos = @photos.page(params[:page]).per(10)
+    end
+    respond_to do |format|
+      format.js
+    end
+  end
+
+  # GET /photos/1
+  # GET /photos/1.xml
+  def show
+    @photo = @user.photos.find(params[:id])
+    update_view_count(@photo) if current_user && current_user.id != @photo.user_id
+    
+    @is_current_user = @user.eql?(current_user)
+    @comment = Comment.new(params[:comment])
+
+    @previous = @photo.previous_photo
+    @next = @photo.next_photo
+    @related = Photo.find_related_to(@photo)
+
+    respond_to do |format|
+      format.html # show.rhtml
+    end
+  end
+
+  # GET /photos/new
+  def new
+    @user = User.find(params[:user_id])
+    @photo = Photo.new
+    if params[:inline]
+      render :action => 'inline_new', :layout => false
+    end
+
+  end
+
+  # GET /photos/1;edit
+  def edit
+    @photo = Photo.find(params[:id])
+    @user = @photo.user
+  end
+
+  # POST /photos
+  # POST /photos.xml
+  def create
+    @user = current_user
+    @photo = Photo.new(params[:photo])
+    @photo.user = @user
+    @photo.tag_list = params[:tag_list] || ''
+    
+    @photo.album_id = params[:album_id] || ''    
+    @photo.album_id = params[:album_selected] unless params[:album_selected].blank?
+
+
+    respond_to do |format|
+      if @photo.save
+        flash[:notice] = :photo_was_successfully_created.l
+
+        format.html {      
+          render :action => 'inline_new', :layout => false and return if params[:inline]
+          if params[:album_id]
+            redirect_to user_album_path(current_user,params[:album_id])
+          else  
+            redirect_to user_photo_url(:id => @photo, :user_id => @photo.user)
+          end
+        }
+        format.js {
+          responds_to_parent do
+            render :update do |page|
+              page << "upload_image_callback('#{@photo.photo.url()}', '#{@photo.display_name}', '#{@photo.id}');"
+            end
+          end
+        }
+      else
+        format.html {
+          render :action => 'inline_new', :layout => false and return if params[:inline]
+          render :action => "new"
+        }
+        format.js {
+          responds_to_parent do
+            render :update do |page|
+              page.alert(:sorry_there_was_an_error_uploading_the_photo.l)
+            end
+          end
+        }
+      end
+    end
+  end
+
+
+  # PUT /photos/1
+  # PUT /photos/1.xml
+  def update
+    @photo = Photo.find(params[:id])
+    @user = @photo.user
+    @photo.tag_list = params[:tag_list] || ''
+    @photo.album_id = params[:photo][:album_id]
+
+    respond_to do |format|
+      if @photo.update_attributes(params[:photo])
+        format.html { redirect_to user_photo_url(@photo.user, @photo) }
+      else
+        format.html { render :action => "edit" }
+      end
+    end
+  end
+
+
+  # DELETE /photos/1
+  # DELETE /photos/1.xml
+  def destroy
+    @user = User.find(params[:user_id])
+    @photo = Photo.find(params[:id])
+    if @user.avatar.eql?(@photo)
+      @user.avatar = nil
+      @user.save!
+    end
+    @photo.destroy
+
+    respond_to do |format|
+      format.html { redirect_to user_photos_url(@photo.user)   }
+    end
+  end
+
+
+  protected
+
+  def description_for_rss(photo)
+    "<a href='#{user_photo_url(photo.user, photo)}' title='#{photo.name}'><img src='#{photo.photo.url(:large)}' alt='#{photo.name}' /><br />#{photo.description}</a>"
+  end
+
+end

data/app/controllers/post_sweeper.rb

@@ -0,0 +1,36 @@
+class PostSweeper < ActionController::Caching::Sweeper
+  observe Post # This sweeper is going to keep an eye on the Post model
+
+  # If our sweeper detects that a Post was created call this
+  def after_create(post)
+    expire_cache_for(post)
+  end
+  
+  # If our sweeper detects that a Post was updated call this
+  def after_update(post)
+    expire_cache_for(post)
+  end
+  
+  # If our sweeper detects that a Post was deleted call this
+  def after_destroy(post)
+    expire_cache_for(post)
+  end
+          
+  private
+  def expire_cache_for(record)
+    # Expire the home page
+    expire_action(:controller => 'base', :action => 'site_index')
+
+    # Expire the footer content
+    expire_action(:controller => 'base', :action => 'footer_content')
+    
+    # Also expire the sitemap
+    expire_action(:controller => 'sitemap', :action => 'index')
+
+    # Expire the category pages
+    expire_action(:controller => 'categories', :action => 'show')
+
+    # Also expire the show pages, in case we just edited a blog entry
+    expire_action(:controller => 'posts', :action => 'show', :id => record.to_param, :user_id => record.user.to_param)
+  end
+end

data/app/controllers/posts_controller.rb

@@ -0,0 +1,252 @@
+class PostsController < BaseController
+  include Viewable
+
+  uses_tiny_mce do
+    {:only => [:new, :edit, :update, :create ], :options => configatron.default_mce_options}
+  end
+
+  uses_tiny_mce do
+    {:only => [:show], :options => configatron.simple_mce_options}
+  end
+         
+  cache_sweeper :post_sweeper, :only => [:create, :update, :destroy]
+  cache_sweeper :taggable_sweeper, :only => [:create, :update, :destroy]    
+  caches_action :show, :if => Proc.new{|c| !logged_in? }
+                           
+  before_filter :login_required, :only => [:new, :edit, :update, :destroy, :create, :manage, :preview]
+  before_filter :find_user, :only => [:new, :edit, :index, :show, :update_views, :manage, :preview]
+  before_filter :require_ownership_or_moderator, :only => [:edit, :update, :destroy, :create, :manage, :new]
+
+  skip_before_filter :verify_authenticity_token, :only => [:update_views, :send_to_friend] #called from ajax on cached pages 
+  
+  def manage
+    Post.unscoped do
+      @search = Post.search(params[:search])
+      @search.meta_sort ||= 'created_at.desc'
+      @posts = @search.where(:user_id => @user.id).page(params[:page]).per(params[:size]||10)
+    end
+  end
+
+  def index
+    @user = User.find(params[:user_id])            
+    @category = Category.find_by_name(params[:category_name]) if params[:category_name]
+
+    @posts = @user.posts.recent
+    @posts = @post.where('category_id = ?', @category.id) if @category
+    @posts = @posts.page(params[:page]).per(10)
+    
+    @is_current_user = @user.eql?(current_user)
+
+    @popular_posts = @user.posts.order("view_count DESC").limit(10).all
+    
+    @rss_title = "#{configatron.community_name}: #{@user.login}'s posts"
+    @rss_url = user_posts_path(@user,:format => :rss)
+        
+    respond_to do |format|
+      format.html # index.rhtml
+      format.rss {
+        render_rss_feed_for(@posts,
+           { :feed => {:title => @rss_title, :link => url_for(:controller => 'posts', :action => 'index', :user_id => @user) },
+             :item => {:title => :title,
+                       :description => :post,
+                       :link => Proc.new {|post| user_post_url(post.user, post)},
+                       :pub_date => :published_at} })
+      }
+    end
+  end
+  
+    
+  # GET /posts/1
+  # GET /posts/1.xml
+  def show
+    @rss_title = "#{configatron.community_name}: #{@user.login}'s posts"
+    @rss_url = user_posts_path(@user,:format => :rss)
+    
+    @post = Post.unscoped.find(params[:id])
+
+    @user = @post.user
+    @is_current_user = @user.eql?(current_user)
+    @comment = Comment.new(params[:comment])
+
+    @comments = @post.comments.includes(:user).order('created_at DESC').limit(20)
+
+    @previous = @post.previous_post
+    @next = @post.next_post    
+    @popular_posts = @user.posts.except(:order).order('view_count DESC').limit(10).all
+    @related = Post.find_related_to(@post)
+    @most_commented = Post.find_most_commented    
+  end
+  
+  def update_views
+    @post = Post.find(params[:id])
+    updated = update_view_count(@post)
+    render :text => updated ? 'updated' : 'duplicate'
+  end
+  
+  def preview
+    @post = Post.unscoped.find(params[:id])
+    redirect_to(:controller => 'sessions', :action => 'new') and return false unless @post.user.eql?(current_user) || admin? || moderator?
+  end
+  
+  # GET /posts/new
+  def new
+    @user = User.find(params[:user_id])    
+    @post = Post.new(params[:post])
+    @post.published_as = 'live'
+    @categories = Category.find(:all)
+  end
+  
+  # GET /posts/1;edit
+  def edit
+    @post = Post.unscoped.find(params[:id])
+  end
+
+  # POST /posts
+  # POST /posts.xml
+  def create    
+    @user = User.find(params[:user_id])
+    @post = Post.new(params[:post])
+    @post.user = @user
+    @post.tag_list = params[:tag_list] || ''
+    
+    respond_to do |format|
+      if @post.save
+        @post.create_poll(params[:poll], params[:choices]) if params[:poll]
+        
+        flash[:notice] = @post.category ? :post_created_for_category.l_with_args(:category => @post.category.name.singularize) : :your_post_was_successfully_created.l
+        format.html { 
+          if @post.is_live?
+            redirect_to @post.category ? category_path(@post.category) : user_post_path(@user, @post) 
+          else
+            redirect_to manage_user_posts_path(@user)
+          end
+        }
+        format.js
+      else
+        format.html { render :action => "new" }
+        format.js        
+      end
+    end
+  end
+  
+  # PUT /posts/1
+  # PUT /posts/1.xml
+  def update
+    @post = Post.unscoped.find(params[:id])
+    @user = @post.user
+    @post.tag_list = params[:tag_list] || ''
+    
+    respond_to do |format|
+      if @post.update_attributes(params[:post])
+        @post.update_poll(params[:poll], params[:choices]) if params[:poll]
+        
+        format.html { redirect_to user_post_path(@post.user, @post) }
+      else
+        format.html { render :action => "edit" }  
+      end
+    end
+  end
+  
+  # DELETE /posts/1
+  # DELETE /posts/1.xml
+  def destroy
+    @user = User.find(params[:user_id])
+    @post = Post.find(params[:id])
+    @post.destroy
+    
+    respond_to do |format|
+      format.html { 
+        flash[:notice] = :your_post_was_deleted.l
+        redirect_to manage_user_posts_url(@user)   
+        }
+    end
+  end
+    
+  def send_to_friend
+    unless params[:emails]
+      render :partial => 'posts/send_to_friend', :locals => {:user_id => params[:user_id], :post_id => params[:post_id]} and return
+    end
+    @post = Post.find(params[:id])
+    if @post.send_to(params[:emails], params[:message], (current_user || nil))
+      render :inline => "It worked!"            
+    else
+      render :inline => "You entered invalid addresses: <ul>"+ @post.invalid_emails.collect{|email| '<li>'+email+'</li>' }.join+"</ul> Please correct these and try again.", :status => 500
+    end
+  end
+
+
+  def popular
+    @posts = Post.find_popular({:limit => 15, :since => 3.days})
+
+    @monthly_popular_posts = Post.find_popular({:limit => 20, :since => 30.days})
+    
+    @related_tags = Tag.find_by_sql("SELECT tags.id, tags.name, count(*) AS count 
+      FROM taggings, tags 
+      WHERE tags.id = taggings.tag_id GROUP BY tags.id, tags.name");
+
+    @rss_title = "#{configatron.community_name} "+:popular_posts.l
+    @rss_url = popular_rss_url    
+    respond_to do |format|
+      format.html # index.rhtml
+      format.rss {
+        render_rss_feed_for(@posts, { :feed => {:title => @rss_title, :link => popular_url},
+          :item => {:title => :title, :link => Proc.new {|post| user_post_url(post.user, post)}, :description => :post, :pub_date => :published_at}
+          })
+      }
+    end
+  end
+  
+  def recent
+    @posts = Post.recent.page(params[:page]).per(20)
+
+    @recent_clippings = Clipping.find_recent(:limit => 15)
+    @recent_photos = Photo.find_recent(:limit => 10)
+    
+    @rss_title = "#{configatron.community_name} "+:recent_posts.l
+    @rss_url = recent_rss_url
+    respond_to do |format|
+      format.html 
+      format.rss {
+        render_rss_feed_for(@posts, { :feed => {:title => @rss_title, :link => recent_url},
+          :item => {:title => :title, :link => Proc.new {|post| user_post_url(post.user, post)}, :description => :post, :pub_date => :published_at}
+          })
+      }
+    end    
+  end
+  
+  def featured
+    @posts = Post.by_featured_writers.recent.page(params[:page])
+    @featured_writers = User.featured
+        
+    @rss_title = "#{configatron.community_name} "+:featured_posts.l
+    @rss_url = featured_rss_url
+    respond_to do |format|
+      format.html 
+      format.rss {
+        render_rss_feed_for(@posts, { :feed => {:title => @rss_title, :link => recent_url},
+          :item => {:title => :title, :link => Proc.new {|post| user_post_url(post.user, post)}, :description => :post, :pub_date => :published_at}
+          })
+      }
+    end    
+  end  
+  
+  def category_tips_update
+    return unless request.xhr?
+    @category = Category.find(params[:post_category_id] )
+    render :partial => "categories/tips", :locals => {:category => @category}    
+  rescue ActiveRecord::RecordNotFound
+    render :partial => "categories/tips", :locals => {:category => nil}    
+  end
+  
+  private
+  
+  def require_ownership_or_moderator
+    @user ||= User.find(params[:user_id])
+    @post ||= Post.unscoped.find(params[:id]) if params[:id]
+    unless admin? || moderator? || (@post && (@post.user.eql?(current_user))) || (!@post && @user && @user.eql?(current_user))
+      redirect_to :controller => 'sessions', :action => 'new' and return false
+    end
+    return @user
+  end
+  
+end

data/app/controllers/rsvps_controller.rb

@@ -0,0 +1,77 @@
+class RsvpsController < BaseController
+
+  before_filter :login_required, :only => [:new, :edit, :update, :destroy, :create]
+  before_filter :find_event
+  before_filter :require_ownership_or_moderator, :only => [:edit, :update, :destroy]
+
+  def find_event
+    @event = Event.find(params[:event_id])
+  rescue
+    redirect_to events_url
+  end
+
+  # GET /rsvps/new
+  def new
+    @rsvp = @event.rsvps.new
+  end
+
+  # GET /posts/1;edit
+  def edit
+  end
+
+  # POST /rsvps
+  # POST /rsvps.xml
+  def create
+    @rsvp = @event.rsvps.new(params[:rsvp])
+    @rsvp.user = current_user
+    respond_to do |format|
+      if @rsvp.save
+        flash[:notice] = :your_rsvp_was_successfully_created.l
+        format.html { redirect_to [@event] }
+        format.js
+      else
+        format.html { render :action => "new" }
+        format.js        
+      end
+    end
+  end
+  
+  # PUT /rsvps/1
+  # PUT /rsvps/1.xml
+  def update
+    @rsvp.attendees_count = params[:rsvp][:attendees_count]
+    respond_to do |format|
+      if @rsvp.save
+        flash[:notice] = :your_rsvp_was_successfully_updated.l
+        format.html { redirect_to [@event] }
+      else
+        format.html { render :action => "edit" }  
+      end
+    end
+  end
+  
+  # DELETE /rsvps/1
+  # DELETE /rsvps/1.xml
+  def destroy
+    @rsvp.destroy
+    respond_to do |format|
+      format.html { 
+        flash[:notice] = :your_rsvp_has_been_retracted.l
+        redirect_to [@event]   
+        }
+    end
+  end
+ 
+  private
+  
+  def require_ownership_or_moderator
+    @rsvp = @event.rsvps.find(params[:id])
+    @user = @rsvp.user
+    unless admin? || moderator? || (@rsvp && (@user.eql?(current_user)))
+      redirect_to [@event] and return false
+    end
+  rescue
+    redirect_to [@event]
+  end
+  
+end

data/app/controllers/sb_posts_controller.rb

@@ -0,0 +1,149 @@
+class SbPostsController < BaseController
+  before_filter :find_post,      :except => [:index, :monitored, :search, :new, :create]
+  before_filter :login_required, :except => [:index, :search, :show, :monitored, :create]
+
+  before_filter :only => [:create] do |controller|
+    login_required unless configatron.allow_anonymous_forum_posting
+  end
+
+  skip_before_filter :verify_authenticity_token, :only => [:create] #remove for the create action
+  before_filter do |controller|
+    #add it back unless anonymous posting is allowed
+    verify_authenticity_token if controller.action_name.eql?('create') && !configatron.allow_anonymous_forum_posting
+  end
+
+  uses_tiny_mce do
+    {:only => [:edit, :update], :options => configatron.default_mce_options}
+  end
+
+
+  def index
+    conditions = []
+    [:user_id, :forum_id].each { |attr| 
+      conditions << SbPost.send(:sanitize_sql, ["sb_posts.#{attr} = ?", params[attr].to_i]) if params[attr] 
+    }
+    conditions = conditions.any? ? conditions.collect { |c| "(#{c})" }.join(' AND ') : nil
+
+    @posts = SbPost.with_query_options.where(conditions).page(params[:page])
+    
+    @users = User.find(:all, :select => 'distinct *', :conditions => ['id in (?)', @posts.collect(&:user_id).uniq]).index_by(&:id)
+    render_posts_or_xml
+  end
+
+  def search
+    conditions = params[:q].blank? ? nil : SbPost.send(:sanitize_sql, ['LOWER(sb_posts.body) LIKE ?', "%#{params[:q]}%"])
+    
+    @posts = SbPost.with_query_options.where(conditions).page(params[:page])
+
+    @users = User.find(:all, :select => 'distinct *', :conditions => ['id in (?)', @posts.collect(&:user_id).uniq]).index_by(&:id)
+    render_posts_or_xml :index
+  end
+
+  def monitored
+    @user = User.find params[:user_id]    
+    @posts = SbPost.with_query_options.joins('INNER JOIN monitorships ON monitorships.topic_id = topics.id').where('monitorships.user_id = ? AND sb_posts.user_id != ?', params[:user_id], @user.id).page(params[:page])
+    render_posts_or_xml
+  end
+
+  def show
+    respond_to do |format|
+      format.html { redirect_to forum_topic_path(@post.forum_id, @post.topic_id) }
+      format.xml  { render :xml => @post.to_xml }
+    end
+  end
+
+  def new
+    if logged_in?
+      redirect_to forum_topic_path(:forum_id => params[:forum_id], :id => params[:topic_id], :anchor => 'reply-form', :page => params[:page] || '1') and return
+    end
+  end
+
+  def create
+    @topic = Topic.find_by_id_and_forum_id(params[:topic_id].to_i, params[:forum_id].to_i, :include => :forum)
+    if @topic.locked?
+      respond_to do |format|
+        format.html do
+          flash[:notice] = :this_topic_is_locked.l
+          redirect_to(forum_topic_path(:forum_id => params[:forum_id], :id => params[:topic_id]))
+        end
+      end
+      return
+    end
+
+    @forum = @topic.forum
+    @post  = @topic.sb_posts.new(params[:post])
+
+    @post.user = current_user if current_user
+    @post.author_ip = request.remote_ip #save the ip address for everyone, just because    
+
+    if (logged_in? || verify_recaptcha(@post)) && @post.save
+      respond_to do |format|
+        format.html do
+          redirect_to forum_topic_path(:forum_id => params[:forum_id], :id => params[:topic_id], :anchor => @post.dom_id, :page => params[:page] || '1')
+        end
+        format.js
+      end
+    else
+      flash.now[:notice] = @post.errors.full_messages.to_sentence
+      respond_to do |format|
+        format.html do
+          redirect_to forum_topic_path({:forum_id => params[:forum_id], :id => params[:topic_id], :anchor => 'reply-form', :page => (params[:page] || '1')}.merge({:post => params[:post]}))
+        end
+        format.js
+      end
+    end
+  end
+  
+  def edit
+    respond_to do |format| 
+      format.html 
+      format.js
+    end
+  end
+  
+  def update
+    @post.attributes = params[:post]
+    @post.save!
+  rescue ActiveRecord::RecordInvalid
+    flash[:bad_reply] = :an_error_occurred.l
+  ensure
+    respond_to do |format|
+      format.html do
+        redirect_to forum_topic_path(:forum_id => params[:forum_id], :id => params[:topic_id], :anchor => @post.dom_id, :page => params[:page] || '1')
+      end
+      format.js
+      format.xml { head 200 }
+    end
+  end
+
+  def destroy
+    @post.destroy
+    flash[:notice] = :sb_post_was_deleted.l_with_args(:title => CGI::escapeHTML(@post.topic.title))
+    # check for posts_count == 1 because its cached and counting the currently deleted post
+    @post.topic.destroy and redirect_to forum_path(params[:forum_id]) if @post.topic.sb_posts_count == 1
+    respond_to do |format|
+      format.html do
+        redirect_to forum_topic_path(:forum_id => params[:forum_id], :id => params[:topic_id], :page => params[:page]) unless performed?
+      end
+      format.xml { head 200 }
+    end
+  end
+
+  protected
+    #overide in your app
+    def authorized?
+      %w(create new).include?(action_name) || @post.editable_by?(current_user)
+    end
+    
+    def find_post
+      @post = SbPost.find_by_id_and_topic_id_and_forum_id(params[:id].to_i, params[:topic_id].to_i, params[:forum_id].to_i) || raise(ActiveRecord::RecordNotFound)
+    end
+    
+    def render_posts_or_xml(template_name = action_name)
+      respond_to do |format|
+        format.html { render :action => "#{template_name}" }
+        format.rss  { render :action => "#{template_name}.xml.builder", :layout => false }
+        format.xml  { render :xml => @posts.to_xml }
+      end
+    end
+end