community_engine 2.0.0.beta1

data/app/controllers/clippings_controller.rb

@@ -0,0 +1,192 @@
+class ClippingsController < BaseController
+  before_filter :login_required, :only => [:new, :edit, :update, :create, :destroy, :new_clipping]
+  before_filter :find_user, :only => [:new, :edit, :index, :show]
+  before_filter :require_current_user, :only => [:new, :edit, :update, :destroy]
+
+  uses_tiny_mce do
+    {:only => [:show,:new_clipping], :options => configatron.default_mce_options}    
+  end
+
+  cache_sweeper :taggable_sweeper, :only => [:create, :update, :destroy]    
+
+  def site_index
+    @clippings = Clipping.includes(:tags).order(params[:recent] ? "created_at DESC" : "clippings.favorited_count DESC")
+    
+    @clippings = @clippings.where('tags.name = ?', params[:tag_name]) if params[:tag_name]
+    @clippings = @clippings.where('created_at > ?', 4.weeks.ago) unless params[:recent]
+
+    @clippings = @clippings.page(params[:page])
+
+    @rss_title = "#{configatron.community_name}: #{params[:popular] ? :popular.l : :recent.l} "+:clippings.l
+    @rss_url = rss_site_clippings_path
+    respond_to do |format|
+      format.html
+      format.rss {
+        render_rss_feed_for(@clippings,
+           { :feed => {:title => @rss_title, :link => url_for(:controller => 'clippings', :action => 'site_index') },
+             :item => {:title => :title_for_rss,
+                       :description => Proc.new {|clip| description_for_rss(clip)},
+                       :link => Proc.new {|clip| user_clipping_url(clip.user, clip)},
+                       :pub_date => :created_at} })
+
+      }
+    end
+
+  end
+
+  # GET /clippings
+  # GET /clippings.xml
+  def index
+    @user = User.find(params[:user_id])
+
+    @clippings = Clipping.includes(:tags).where(:user_id => @user.id).order("created_at DESC")
+
+    @clippings = @clippings.where('tags.name = ?', params[:tag_name]) if params[:tag_name]
+
+    @clippings = @clippings.page(params[:page])
+    
+    @tags = Clipping.includes(:taggings).where(:user_id => @user.id).tag_counts(:limit => 20)    
+    
+    @clippings_data = @clippings.collect {|c| [c.id, c.image_url, c.description, c.url ]  }
+
+    @rss_title = "#{configatron.community_name}: #{@user.login}'s clippings"
+    @rss_url = user_clippings_path(@user,:format => :rss)
+
+    respond_to do |format|
+      format.html # index.rhtml
+      format.js { render :inline => @clippings_data.to_json }
+      # format.widget { render :template => 'clippings/widget', :layout => false }
+      format.rss {
+        render_rss_feed_for(@clippings,
+           { :feed => {:title => @rss_title, :link => url_for(:controller => 'clippings', :action => 'index', :user_id => @user) },
+             :item => {:title => :title_for_rss,
+                       :description => Proc.new {|clip| description_for_rss(clip)},
+                       :link => :url,
+                       :pub_date => :created_at} })
+
+      }
+    end
+  end
+
+  # GET /clippings/1
+  # GET /clippings/1.xml
+  def show
+    @user = User.find(params[:user_id])
+    @clipping = Clipping.find(params[:id])
+    @previous = @clipping.previous_clipping
+    @next = @clipping.next_clipping
+
+    @related = Clipping.find_related_to(@clipping)
+
+    respond_to do |format|
+      format.html # show.rhtml
+    end
+  end
+
+  def load_images_from_uri
+    uri = URI.parse(params[:uri])
+    begin
+      doc = Hpricot( open( uri ) )
+    rescue
+      render :inline => "<h1>Sorry, there was an error fetching the images from the page you requested</h1><a href='#{params[:uri]}'>Go back...</a>"
+      return
+    end
+    @page_title = (doc/"title")
+    # get the images
+    @images = []
+    (doc/"img").each do |img|
+      begin
+        if URI.parse(URI.escape(img['src'])).scheme.nil?
+          img_uri = "#{uri.scheme}://#{uri.host}/#{img['src']}"
+        else
+          img_uri = img['src']
+        end
+        @images << img_uri
+      rescue
+        nil
+      end
+    end
+    respond_to do |format|
+      format.js
+    end
+  end
+
+  def new_clipping
+    @user = current_user
+    @clipping = @user.clippings.new({:url => params[:uri], :description => params[:selection]})
+    @post = @user.posts.new_from_bookmarklet(params)
+    render :action => "new_clipping", :layout => false
+  end
+
+  # GET /clippings/new
+  def new
+    @user = User.find(params[:user_id])
+    @clipping = @user.clippings.new
+  end
+
+  # GET /clippings/1;edit
+  def edit
+    @clipping = Clipping.find(params[:id])
+    @user = User.find(params[:user_id])
+  end
+
+  # POST /clippings
+  # POST /clippings.xml
+  def create
+    @user = current_user
+    @clipping = @user.clippings.new(params[:clipping])
+    @clipping.user = @user
+    @clipping.tag_list = params[:tag_list] || ''
+
+    respond_to do |format|
+      if @clipping.save!
+        flash[:notice] = :clipping_was_successfully_created.l
+        format.html {
+          unless params[:user_id]
+            redirect_to @clipping.url rescue redirect_to user_clipping_url(@user, @clipping)
+          else
+            redirect_to user_clipping_url(@user, @clipping)
+          end
+        }
+      else
+        format.html { render :action => "new" }
+      end
+    end
+  end
+
+  # PUT /clippings/1
+  # PUT /clippings/1.xml
+  def update
+    @user = User.find(params[:user_id])
+    @clipping = Clipping.find(params[:id])
+    @clipping.tag_list = params[:tag_list] || ''
+
+    if @clipping.update_attributes(params[:clipping])
+      respond_to do |format|
+        format.html { redirect_to user_clipping_url(@user, @clipping) }
+      end
+    else
+      respond_to do |format|      
+        format.html { render :action => "edit" }
+      end
+    end
+  end
+
+  # DELETE /clippings/1
+  # DELETE /clippings/1.xml
+  def destroy
+    @user = User.find(params[:user_id])
+    @clipping = Clipping.find(params[:id])
+    @clipping.destroy
+
+    respond_to do |format|
+      format.html { redirect_to user_clippings_url(@user)   }
+    end
+  end
+
+  protected
+
+  def description_for_rss(clip)
+    "<a href='#{user_clipping_url(clip.user, clip)}' title='#{clip.title_for_rss}'><img src='#{clip.image_url}' alt='#{clip.description}' /></a>"
+  end
+end

data/app/controllers/comment_sweeper.rb

@@ -0,0 +1,35 @@
+class CommentSweeper < ActionController::Caching::Sweeper
+  observe Comment
+
+  def after_create(comment)
+    expire_cache_for(comment)
+  end
+  
+  # If our sweeper detects that a comment was updated call this
+  def after_update(comment)
+    expire_cache_for(comment)
+  end
+  
+  # If our sweeper detects that a comment was deleted call this
+  def after_destroy(comment)
+    expire_cache_for(comment)
+  end
+          
+  private
+  def expire_cache_for(record)
+    # Expire the footer content
+    expire_action :controller => 'base', :action => 'footer_content'
+
+    if record.commentable_type.eql?('Post') 
+      expire_action :controller => 'posts', :action => 'show', :id => record.commentable.to_param , :user_id => record.commentable.user.to_param
+      
+      if Post.find_recent(:limit => 16).include?(record.commentable)
+        # Expire the home page    
+        expire_action :controller => 'base', :action => 'site_index'
+        # Expire the category pages
+        expire_action :controller => 'categories', :action => 'show', :id => record.commentable.category
+      end
+    end
+
+  end
+end

data/app/controllers/comments_controller.rb

@@ -0,0 +1,179 @@
+class CommentsController < BaseController
+  before_filter :login_required, :except => [:index, :unsubscribe]
+  before_filter :admin_or_moderator_required, :only => [:delete_selected, :edit, :update]
+
+  if configatron.allow_anonymous_commenting
+    skip_before_filter :verify_authenticity_token, :only => [:create]   #because the auth token might be cached anyway
+    skip_before_filter :login_required, :only => [:create]
+  end
+
+  uses_tiny_mce do
+    {:only => [:index, :edit, :update], :options => configatron.simple_mce_options}
+  end
+
+  cache_sweeper :comment_sweeper, :only => [:create, :destroy]
+  
+  def edit
+    @comment = Comment.find(params[:id])
+    respond_to do |format|
+      format.js
+    end
+  end
+
+  def update
+    @comment = Comment.find(params[:id])
+    @comment.update_attributes(params[:comment])    
+    respond_to do |format|
+      format.js
+    end    
+  end
+
+
+  def index
+    commentable_type = get_commentable_type(params[:commentable_type])
+    commentable_class = commentable_type.singularize.constantize
+    commentable_type_humanized = commentable_type.humanize
+    commentable_type_tableized = commentable_type.tableize
+    
+    if @commentable = commentable_class.find(params[:commentable_id])
+      unless logged_in? || (@commentable.owner && @commentable.owner.profile_public?)
+        flash.now[:error] = :private_user_profile_message.l
+        redirect_to login_path and return
+      end
+      
+      @comments = @commentable.comments.recent.page(params[:page])
+      @title = commentable_type_humanized            
+      @rss_url = commentable_comments_url(commentable_type_tableized, @commentable, :format => :rss)
+
+      if @comments.any?
+        first_comment = @comments.first
+        @user = first_comment.recipient
+        @title = first_comment.commentable_name
+        @back_url = commentable_url(first_comment)
+        respond_to do |format|
+          @rss_title = "#{configatron.community_name}: #{commentable_type_humanized} Comments - #{@title}"                
+          format.html
+          format.rss {
+            render_comments_rss_feed_for(@comments, @commentable, @rss_title) and return
+          }
+        end              
+      else
+        if @commentable.is_a?(User)
+          @user = @commentable
+          @title = @user.login
+          @back_url = user_path(@user)
+        elsif @user = @commentable.user
+          @title = @commentable.try(:title) || @commentable.try(:description) || @title
+          @back_url = url_for([@user, @commentable])
+        end
+        
+        respond_to do |format|
+          format.html
+          format.rss {
+            @rss_title = "#{configatron.community_name}: #{commentable_type_humanized} Comments - #{@title}"                            
+            render_comments_rss_feed_for([], @commentable, @rss_title) and return
+          }
+        end        
+      end   
+    else
+      flash[:notice] = :no_comments_found.l_with_args(:type => commentable_type_humanized)
+      redirect_to home_path
+    end          
+  end
+
+  def new
+    @commentable = get_commentable_type(params[:commentable_type]).constantize.find(params[:commentable_id])
+    redirect_to commentable_comments_url(@commentable.class.to_s.tableize, @commentable.id)
+  end
+
+
+  def create
+    commentable_type = get_commentable_type(params[:commentable_type])
+    @commentable = commentable_type.singularize.constantize.find(params[:commentable_id])
+
+    @comment = Comment.new(params[:comment])
+
+    @comment.commentable = @commentable
+    @comment.recipient = @commentable.owner
+    @comment.user_id = current_user.id if current_user
+    @comment.author_ip = request.remote_ip #save the ip address for everyone, just because
+
+    respond_to do |format|
+      if (logged_in? || verify_recaptcha(@comment)) && @comment.save
+        @comment.send_notifications
+
+        flash.now[:notice] = :comment_was_successfully_created.l
+        format.html { redirect_to commentable_url(@comment) }
+        format.js
+      else
+        flash.now[:error] = :comment_save_error.l_with_args(:error => @comment.errors.full_messages.to_sentence)
+        format.html { redirect_to commentable_comments_path(commentable_type.tableize, @commentable) }
+        format.js
+      end
+    end
+  end
+
+  def destroy
+    @comment = Comment.find(params[:id])
+    if @comment.can_be_deleted_by(current_user) && @comment.destroy
+      if params[:spam] && !configatron.akismet_key.nil?
+        @comment.spam!
+      end
+      flash.now[:notice] = :the_comment_was_deleted.l
+    else
+      flash.now[:error] = :comment_could_not_be_deleted.l
+    end
+    respond_to do |format|
+      format.html { redirect_to users_url }
+      format.js   {
+        render :inline => flash[:error], :status => 500 if flash[:error]
+        render :nothing => true if flash[:notice]
+      }
+    end
+  end
+  
+  def delete_selected
+    if request.post?
+      if params[:delete]
+        params[:delete].each { |id|
+          comment = Comment.find(id)
+          comment.spam! if params[:spam] && !configatron.akismet_key.nil?
+          comment.destroy if comment.can_be_deleted_by(current_user)
+        }
+      end
+      flash[:notice] = :comments_deleted.l                
+      redirect_to admin_comments_path
+    end
+  end  
+
+  
+  def unsubscribe
+    @comment = Comment.find(params[:comment_id])
+    if @comment.token_for(params[:email]).eql?(params[:token])
+      @comment.unsubscribe_notifications(params[:email])
+      flash[:notice] = :comment_unsubscribe_succeeded.l
+    end
+    redirect_to commentable_url(@comment)
+  end
+
+
+  private
+    
+    def get_commentable_type(string)
+      string.camelize
+    end
+        
+    def render_comments_rss_feed_for(comments, commentable, title)
+      render_rss_feed_for(comments,
+        { :class => commentable.class,
+          :feed => {  :title => title,
+                      :link => commentable_comments_url(commentable.class.to_s.tableize, commentable) },
+          :item => { :title => :title_for_rss,
+                     :description => :comment,
+                     :link => Proc.new {|comment| commentable_url(comment)},
+                     :pub_date => :created_at
+                     }
+        })
+    end
+  
+end

data/app/controllers/event_sweeper.rb

@@ -0,0 +1,24 @@
+class EventSweeper < ActionController::Caching::Sweeper
+  observe Event # This sweeper is going to keep an eye on the Event model
+
+  # If our sweeper detects that an Event was created call this
+  def after_create(event)
+    expire_cache_for(event)
+  end
+  
+  # If our sweeper detects that an Event was updated call this
+  def after_update(event)
+    expire_cache_for(event)
+  end
+  
+  # If our sweeper detects that an Event was deleted call this
+  def after_destroy(event)
+    expire_cache_for(event)
+  end
+          
+  private
+  def expire_cache_for(record)
+    # Expire the ical page
+    expire_page(:controller => 'events', :action => 'ical', :format => 'ics')
+  end
+end

data/app/controllers/events_controller.rb

@@ -0,0 +1,173 @@
+class EventsController < BaseController
+
+  require 'htmlentities'
+  caches_page :ical
+  cache_sweeper :event_sweeper, :only => [:create, :update, :destroy]
+ 
+
+  uses_tiny_mce do
+    {:only => [:new, :edit, :create, :update, :clone ], :options => configatron.default_mce_options}
+  end
+  
+  uses_tiny_mce do
+    {:only => [:show], :options => configatron.simple_mce_options}
+  end
+
+  before_filter :admin_required, :except => [:index, :show, :ical]
+
+  def ical
+    @calendar = RiCal.Calendar
+    @calendar.add_x_property 'X-WR-CALNAME', configatron.community_name
+    @calendar.add_x_property 'X-WR-CALDESC', "#{configatron.community_name} #{:events.l}"
+    Event.find(:all).each do |ce_event|
+      rical_event = RiCal.Event do |event|
+        event.dtstart = ce_event.start_time
+        event.dtend = ce_event.end_time
+        event.summary = ce_event.name + (ce_event.metro_area.blank? ? '' : " (#{ce_event.metro_area})")
+        coder = HTMLEntities.new
+        event.description = (ce_event.description.blank? ? '' : coder.decode(help.strip_tags(ce_event.description).to_s) + "\n\n") + event_url(ce_event)
+        event.location = ce_event.location unless ce_event.location.blank?
+      end
+      @calendar.add_subcomponent rical_event
+    end
+    headers['Content-Type'] = "text/calendar; charset=UTF-8"
+    render :text => @calendar.export_to, :layout => false
+  end
+
+  def show
+    @is_admin_user = (current_user && current_user.admin?)
+    @event = Event.find(params[:id])
+    @comments = @event.comments.find(:all, :limit => 20, :order => 'created_at DESC', :include => :user)
+  end
+
+  def index
+    @is_admin_user = (current_user && current_user.admin?)
+    @events = Event.upcoming.page(params[:page])
+  end
+
+  def past
+    @is_admin_user = (current_user && current_user.admin?)
+    @events = Event.past.page(params[:page])
+    render :template => 'events/index'
+  end
+
+  def new
+    @event = Event.new(params[:event])
+    @metro_areas, @states = setup_metro_area_choices_for(current_user)
+    @metro_area_id, @state_id, @country_id = setup_location_for(current_user)
+  end
+  
+  def edit
+    @event = Event.find(params[:id])
+    @metro_areas, @states = setup_metro_area_choices_for(@event)
+    @metro_area_id, @state_id, @country_id = setup_location_for(@event)
+  end
+    
+  def create
+    @event = Event.new(params[:event])
+    @event.user = current_user
+    if params[:metro_area_id]
+      @event.metro_area = MetroArea.find(params[:metro_area_id])
+    else
+      @event.metro_area = nil
+    end
+    respond_to do |format|
+      if @event.save
+        flash[:notice] = :event_was_successfully_created.l
+        
+        format.html { redirect_to event_path(@event) }
+      else
+        format.html { 
+          @metro_areas, @states = setup_metro_area_choices_for(@event)
+          if params[:metro_area_id]
+            @metro_area_id = params[:metro_area_id].to_i
+            @state_id = params[:state_id].to_i
+            @country_id = params[:country_id].to_i
+          end
+          render :action => "new"
+        }
+      end
+    end    
+  end
+
+  def update
+    @event = Event.find(params[:id])
+    if params[:metro_area_id]
+      @event.metro_area = MetroArea.find(params[:metro_area_id])
+    else
+      @event.metro_area = nil
+    end
+        
+    respond_to do |format|
+      if @event.update_attributes(params[:event])
+        format.html { redirect_to event_path(@event) }
+      else
+        format.html { 
+          @metro_areas, @states = setup_metro_area_choices_for(@event)
+          if params[:metro_area_id]
+            @metro_area_id = params[:metro_area_id].to_i
+            @state_id = params[:state_id].to_i
+            @country_id = params[:country_id].to_i
+          end
+          render :action => "edit"
+        }
+      end
+    end
+  end
+  
+  def destroy
+    @event = Event.find(params[:id])
+    @event.destroy
+    
+    respond_to do |format|
+      format.html { redirect_to :back }
+    end
+  end
+
+  def clone
+    @event = Event.find(params[:id]).clone
+    @metro_areas, @states = setup_metro_area_choices_for(@event)
+    @metro_area_id, @state_id, @country_id = setup_location_for(@event)
+    render :template => 'events/new'
+  end
+
+  protected
+
+  def setup_metro_area_choices_for(object)
+    metro_areas = states = []
+    if object.metro_area
+      if object.is_a? Event
+        states = object.metro_area.country.states
+        if object.metro_area.state
+          metro_areas = object.metro_area.state.metro_areas.all(:order=>"name")
+        else
+          metro_areas = object.metro_area.country.metro_areas.all(:order=>"name")
+        end        
+      elsif object.is_a? User
+        states = object.country.states if object.country
+        if object.state
+          metro_areas = object.state.metro_areas.all(:order => "name")
+        else
+          metro_areas = object.country.metro_areas.all(:order => "name")
+        end
+      end
+    end
+    return metro_areas, states
+  end
+
+  def setup_location_for(object)
+    metro_area_id = state_id = country_id = nil
+    if object.metro_area
+      metro_area_id = object.metro_area_id
+      if object.is_a? Event
+        state_id = object.metro_area.state_id
+        country_id = object.metro_area.country_id
+      elsif object.is_a? User
+        state_id = object.state_id
+        country_id = object.country_id
+      end
+    end
+    return metro_area_id, state_id, country_id
+  end
+
+end

data/app/controllers/favorite_sweeper.rb

@@ -0,0 +1,29 @@
+class FavoriteSweeper < ActionController::Caching::Sweeper
+  observe Favorite
+
+  def after_create(favorite)
+    expire_cache_for(favorite)
+  end
+    
+  def after_destroy(favorite)
+    expire_cache_for(favorite)
+  end
+          
+  private
+  def expire_cache_for(record)
+    #the favorite is for a post
+    if record.favoritable_type.eql?('Post')
+      # expire the show page
+      expire_page :controller => 'posts', :action => 'show', :id => record.favoritable, :user_id => record.favoritable.user
+      
+      if Post.find_recent(:limit => 16).include?(record.favoritable)
+        # Expire the home page
+        expire_action :controller => 'base', :action => 'site_index'
+
+        # Expire the category page for this post
+        expire_action :controller => 'categories', :action => 'show', :id => record.favoritable.category
+      end
+    end
+        
+  end
+end

data/app/controllers/favorites_controller.rb

@@ -0,0 +1,36 @@
+class FavoritesController < BaseController
+  before_filter :login_required, :only => [:destroy]
+  before_filter :find_user, :only => [:show, :index]
+
+  cache_sweeper :favorite_sweeper, :only => [:create, :destroy]  
+  
+  def create
+    @favoritable = params[:favoritable_type].classify.constantize.find(params[:favoritable_id])
+    @favorite = Favorite.new(:ip_address => request.remote_ip, :favoritable => @favoritable )
+    @favorite.user = current_user || nil
+    @favorite.save
+    
+    respond_to do |format|
+      format.js
+    end
+  end
+  
+  def destroy
+    @favorite = current_user.favorites.find(params[:id])
+    @favorite.destroy
+    
+    respond_to do |format|
+      format.js
+    end    
+  end
+  
+  def show
+    @favorite = @user.favorites.find(params[:id])
+  end
+  
+  def index  
+    @favorites = Favorite.recent.by_user(@user).page(params[:page])
+  end
+  
+  
+end