community_engine 2.0.0.beta1

data/app/controllers/forums_controller.rb

@@ -0,0 +1,71 @@
+class ForumsController < BaseController
+  before_filter :login_required, :except => [:index, :show]
+  before_filter :find_or_initialize_forum
+
+  uses_tiny_mce do    
+    {:options => configatron.default_mce_options}
+  end
+  
+  def index
+    @forums = Forum.find(:all, :order => "position")
+    respond_to do |format|
+      format.html
+      format.xml { render :xml => @forums.to_xml }
+    end
+  end
+
+  def show
+    respond_to do |format|
+      format.html do
+        # keep track of when we last viewed this forum for activity indicators
+        (session[:forums] ||= {})[@forum.id] = Time.now.utc if logged_in?
+
+        @topics = @forum.topics.includes(:replied_by_user).order('sticky DESC, replied_at DESC').page(params[:page]).per(20)
+      end
+      
+      format.xml do
+        render :xml => @forum.to_xml
+      end
+    end
+  end
+
+  # new renders new.rhtml
+  
+  def create
+    @forum.attributes = params[:forum]
+    @forum.tag_list = params[:tag_list] || ''
+    @forum.save!
+    respond_to do |format|
+      format.html { redirect_to forums_path }
+      format.xml  { head :created, :location => forum_url(:id => @forum, :format => :xml) }
+    end
+  end
+
+  def update
+    @forum.attributes = params[:forum]
+    @forum.tag_list = params[:tag_list] || ''
+    @forum.save!
+    respond_to do |format|
+      format.html { redirect_to forums_path }
+      format.xml  { head 200 }
+    end
+  end
+  
+  def destroy
+    @forum.destroy
+    respond_to do |format|
+      format.html { redirect_to forums_path }
+      format.xml  { head 200 }
+    end
+  end
+  
+  protected
+    def find_or_initialize_forum
+      @forum = params[:id] ? Forum.find(params[:id]) : Forum.new
+    end
+
+  #overide in your app
+  def authorized?
+    current_user.admin?
+  end
+end

data/app/controllers/friendships_controller.rb

@@ -0,0 +1,126 @@
+class FriendshipsController < BaseController
+  before_filter :login_required, :except => [:accepted, :index]
+  before_filter :find_user, :only => [:accepted, :pending, :denied]
+  before_filter :require_current_user, :only => [:accept, :deny, :pending, :destroy]
+
+  def index
+    @body_class = 'friendships-browser'
+    
+    @user = (params[:id] ||params[:user_id]) ? User.find((params[:id] || params[:user_id] )): Friendship.find(:first).user
+    @friendships = Friendship.find(:all, :conditions => ['user_id = ? OR friend_id = ?', @user.id, @user.id], :limit => 40)
+    @users = User.find(:all, :conditions => ['users.id in (?)', @friendships.collect{|f| f.friend_id }])    
+    
+    respond_to do |format|
+      format.html 
+      format.xml { render :action => 'index.rxml', :layout => false}    
+    end
+  end
+  
+  def deny
+    @user = User.find(params[:user_id])    
+    @friendship = @user.friendships.find(params[:id])
+ 
+    respond_to do |format|
+      if @friendship.update_attributes(:friendship_status => FriendshipStatus[:denied]) && @friendship.reverse.update_attributes(:friendship_status => FriendshipStatus[:denied])
+        flash[:notice] = :the_friendship_was_denied.l
+        format.html { redirect_to denied_user_friendships_path(@user) }
+      else
+        format.html { render :action => "edit" }
+      end
+    end    
+  end
+
+  def accept
+    @user = User.find(params[:user_id])    
+    @friendship = @user.friendships_not_initiated_by_me.find(params[:id])
+ 
+    respond_to do |format|
+      if @friendship.update_attributes(:friendship_status => FriendshipStatus[:accepted]) && @friendship.reverse.update_attributes(:friendship_status => FriendshipStatus[:accepted])
+        flash[:notice] = :the_friendship_was_accepted.l
+        format.html { 
+          redirect_to accepted_user_friendships_path(@user) 
+        }
+      else
+        format.html { render :action => "edit" }
+      end
+    end
+  end
+
+  def denied
+    @user = User.find(params[:user_id])    
+    @friendships = @user.friendships.where("friendship_status_id = ?", FriendshipStatus[:denied].id).page(params[:page])
+    
+    respond_to do |format|
+      format.html
+    end
+  end
+
+
+  def accepted
+    @user = User.find(params[:user_id])    
+    @friend_count = @user.accepted_friendships.count
+    @pending_friendships_count = @user.pending_friendships.count
+          
+    @friendships = @user.friendships.accepted.page(params[:page]).per(12)
+    
+    respond_to do |format|
+      format.html
+    end
+  end
+  
+  def pending
+    @user = User.find(params[:user_id])    
+    @friendships = @user.friendships.find(:all, :conditions => ["initiator = ? AND friendship_status_id = ?", false, FriendshipStatus[:pending].id])
+    
+    respond_to do |format|
+      format.html
+    end
+  end
+  
+  def show
+    @friendship = Friendship.find(params[:id])
+    @user = @friendship.user
+    
+    respond_to do |format|
+      format.html
+    end
+  end
+  
+
+  def create
+    @user = User.find(params[:user_id])
+    @friendship = Friendship.new(:user_id => params[:user_id], :friend_id => params[:friend_id], :initiator => true )
+    @friendship.friendship_status_id = FriendshipStatus[:pending].id    
+    reverse_friendship = Friendship.new(params[:friendship])
+    reverse_friendship.friendship_status_id = FriendshipStatus[:pending].id 
+    reverse_friendship.user_id, reverse_friendship.friend_id = @friendship.friend_id, @friendship.user_id
+    
+    respond_to do |format|
+      if @friendship.save && reverse_friendship.save
+        UserNotifier.friendship_request(@friendship).deliver if @friendship.friend.notify_friend_requests?
+        format.html {
+          flash[:notice] = :friendship_requested.l_with_args(:friend => @friendship.friend.login) 
+          redirect_to accepted_user_friendships_path(@user)
+        }
+        format.js { render( :inline => :requested_friendship_with.l+" #{@friendship.friend.login}." ) }        
+      else
+        flash.now[:error] = :friendship_could_not_be_created.l
+        format.html { redirect_to user_friendships_path(@user) }
+        format.js { render( :inline => "Friendship request failed." ) }                
+      end
+    end
+  end
+    
+  def destroy
+    @user = User.find(params[:user_id])    
+    @friendship = Friendship.find(params[:id])
+    Friendship.transaction do 
+      @friendship.destroy
+      @friendship.reverse.destroy
+    end
+    respond_to do |format|
+      format.html { redirect_to accepted_user_friendships_path(@user) }
+    end
+  end
+  
+end

data/app/controllers/homepage_features_controller.rb

@@ -0,0 +1,68 @@
+class HomepageFeaturesController < BaseController
+  uses_tiny_mce do
+    {:only => [:new, :edit, :create, :update ], :options => configatron.default_mce_options}
+  end
+
+  before_filter :login_required
+  before_filter :admin_required
+
+  def index
+    @search = HomepageFeature.search(params[:search])
+    @search.meta_sort ||= 'created_at.desc'    
+    @homepage_features = @search.page(params[:page]).per(100)
+    respond_to do |format|
+      format.html
+    end
+  end
+  
+  def show
+    @homepage_feature = HomepageFeature.find(params[:id])
+    
+    respond_to do |format|
+      format.html 
+    end
+  end
+  
+  def new
+    @homepage_feature = HomepageFeature.new
+  end
+  
+  def edit
+    @homepage_feature = HomepageFeature.find(params[:id])
+  end
+
+  def create
+    @homepage_feature = HomepageFeature.new(params[:homepage_feature])
+    
+    respond_to do |format|
+      if @homepage_feature.save
+        flash[:notice] = :homepage_feature_created.l
+        
+        format.html { redirect_to homepage_feature_url(@homepage_feature) }
+      else
+        format.html { render :action => "new" }
+      end
+    end
+  end
+  
+  def update
+    @homepage_feature = HomepageFeature.find(params[:id])
+    
+    respond_to do |format|
+      if @homepage_feature.update_attributes(params[:homepage_feature])
+        format.html { redirect_to homepage_feature_url(@homepage_feature) }
+      else
+        format.html { render :action => "edit" }
+      end
+    end
+  end
+  
+  def destroy
+    @homepage_feature = HomepageFeature.find(params[:id])
+    @homepage_feature.destroy
+    
+    respond_to do |format|
+      format.html { redirect_to homepage_features_url   }
+    end
+  end
+end

data/app/controllers/invitations_controller.rb

@@ -0,0 +1,46 @@
+class InvitationsController < BaseController
+  before_filter :login_required
+
+  def index
+    @user = current_user
+    @invitations = @user.invitations
+
+    respond_to do |format|
+      format.html 
+    end
+  end
+  
+  def new
+    @user = current_user
+    @invitation = Invitation.new
+  end
+  
+
+  def edit
+    @invitation = Invitation.find(params[:id])
+  end
+
+
+  def create
+    @user = current_user
+
+    @invitation = Invitation.new(params[:invitation])
+    @invitation.user = @user
+    
+    respond_to do |format|
+      if @invitation.save
+        flash[:notice] = :invitation_was_successfully_created.l
+        format.html { 
+          unless params[:welcome]
+            redirect_to user_path(@invitation.user) 
+          else
+            redirect_to welcome_complete_user_path(@invitation.user)            
+          end
+        }
+      else
+        format.html { render :action => "new" }
+      end
+    end
+  end
+  
+end

data/app/controllers/messages_controller.rb

@@ -0,0 +1,95 @@
+class MessagesController < BaseController
+  before_filter :find_user, :except => [:auto_complete_for_username]
+  before_filter :login_required
+  before_filter :require_ownership_or_moderator, :except => [:auto_complete_for_username]
+
+  skip_before_filter :verify_authenticity_token, :only => [:auto_complete_for_username]
+  
+  def auto_complete_for_username
+    @users = User.find(:all, :conditions => [ 'LOWER(login) LIKE ?', '%' + (params[:message][:to]) + '%' ])
+    render :inline => "<%= auto_complete_result(@users, 'login') %>"
+  end
+    
+  def index
+    if params[:mailbox] == "sent"
+      @messages = @user.sent_messages.page(params[:page]).per(20)
+    else
+      @messages = @user.message_threads_as_recipient.order('updated_at DESC').page(params[:page]).per(20)
+    end
+  end
+  
+  def show
+    @message = Message.read(params[:id], current_user)
+    @message_thread = MessageThread.for(@message, (admin? ? @message.recipient : current_user ))
+    @reply = Message.new_reply(@user, @message_thread, params)    
+  end
+  
+  def new
+    if params[:reply_to]
+      in_reply_to = Message.find_by_id(params[:reply_to])
+      message_thread = MessageThread.for(in_reply_to, current_user)
+    end
+    @message = Message.new_reply(@user, message_thread, params)    
+  end
+  
+  def create
+    messages = []
+
+    if params[:message][:to].blank?
+      # If 'to' field is empty, call validations to catch other errors
+      @message = Message.new(params[:message])        
+      @message.valid?
+      render :action => :new and return
+    else
+      @message = Message.new(params[:message])          
+      @message.recipient = User.find_by_login(params[:message][:to].strip)
+      @message.sender = @user
+      unless @message.valid?
+        render :action => :new and return        
+      else
+        @message.save!
+      end
+      flash[:notice] = :message_sent.l
+      redirect_to user_messages_path(@user) and return
+    end
+  end
+
+  def delete_selected
+    if request.post?
+      if params[:delete]
+        params[:delete].each { |id|
+          @message = Message.find(:first, :conditions => ["messages.id = ? AND (sender_id = ? OR recipient_id = ?)", id, @user, @user])
+          @message.mark_deleted(@user) unless @message.nil?
+        }
+        flash[:notice] = :messages_deleted.l
+      end
+      redirect_to user_messages_path(@user)
+    end
+  end
+  
+  def delete_message_threads
+    if request.post?
+      if params[:delete]
+        params[:delete].each { |id|
+          message_thread = MessageThread.find_by_id_and_recipient_id(id, @user.id)
+          message_thread.destroy if message_thread
+        }
+        flash[:notice] = :messages_deleted.l
+      end
+      redirect_to user_messages_path(@user)
+    end
+
+  end
+  
+  private
+    def find_user
+      @user = User.find(params[:user_id])
+    end
+
+    def require_ownership_or_moderator
+      unless admin? || moderator? || (@user && (@user.eql?(current_user)))
+        redirect_to :controller => 'sessions', :action => 'new' and return false
+      end
+      return @user
+    end    
+end

data/app/controllers/metro_areas_controller.rb

@@ -0,0 +1,68 @@
+class MetroAreasController < BaseController
+  before_filter :login_required
+  before_filter :admin_required
+
+  def index
+    @metro_areas = MetroArea.order("countries.name, metro_areas.name DESC").includes(:country).page(params[:page])
+  end
+  
+  def show
+    @metro_area = MetroArea.find(params[:id])
+    
+    respond_to do |format|
+      format.html 
+      format.xml  { render :xml => @metro_area.to_xml }
+    end
+  end
+  
+  def new
+    @metro_area = MetroArea.new
+  end
+  
+  def edit
+    @metro_area = MetroArea.find(params[:id])
+  end
+
+  def create
+    @metro_area = MetroArea.new(params[:metro_area])
+    
+    respond_to do |format|
+      if @metro_area.save
+        flash[:notice] = :metro_area_was_successfully_created.l
+        
+        format.html { redirect_to metro_area_url(@metro_area) }
+        format.xml do
+          headers["Location"] = metro_area_url(@metro_area)
+          render :nothing => true, :status => "201 Created"
+        end
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @metro_area.errors.to_xml }
+      end
+    end
+  end
+  
+  def update
+    @metro_area = MetroArea.find(params[:id])
+    
+    respond_to do |format|
+      if @metro_area.update_attributes(params[:metro_area])
+        format.html { redirect_to metro_area_url(@metro_area) }
+        format.xml  { render :nothing => true }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @metro_area.errors.to_xml }        
+      end
+    end
+  end
+  
+  def destroy
+    @metro_area = MetroArea.find(params[:id])
+    @metro_area.destroy
+    
+    respond_to do |format|
+      format.html { redirect_to metro_areas_url   }
+      format.xml  { render :nothing => true }
+    end
+  end
+end

data/app/controllers/moderators_controller.rb

@@ -0,0 +1,26 @@
+class ModeratorsController < BaseController
+  before_filter :login_required
+  
+  def create
+    @forum = Forum.find(params[:forum_id])
+    @user = User.find(params[:user_id])
+    @moderatorship = Moderatorship.create!(:forum => @forum, :user => @user)
+    respond_to do |format|
+      format.js
+    end
+
+  end
+
+  def destroy
+    @moderatorship = Moderatorship.find(params[:id])
+    @moderatorship.destroy
+    respond_to do |format|
+      format.js
+    end
+  end
+
+  #overide in your app
+  def authorized?
+    current_user.admin?
+  end
+end

data/app/controllers/monitorships_controller.rb

@@ -0,0 +1,20 @@
+class MonitorshipsController < BaseController
+  before_filter :login_required
+
+  def create
+    @monitorship = Monitorship.find_or_initialize_by_user_id_and_topic_id(current_user.id, params[:topic_id])
+    @monitorship.update_attribute :active, true
+    respond_to do |format| 
+      format.html { redirect_to forum_topic_path(params[:forum_id], params[:topic_id]) }
+      format.js
+    end
+  end
+  
+  def destroy
+    Monitorship.update_all ['active = ?', false], ['user_id = ? and topic_id = ?', current_user.id, params[:topic_id]]
+    respond_to do |format| 
+      format.html { redirect_to forum_topic_path(params[:forum_id], params[:topic_id]) }
+      format.js
+    end
+  end
+end

data/app/controllers/page_sweeper.rb

@@ -0,0 +1,33 @@
+class PageSweeper < ActionController::Caching::Sweeper
+  observe Page # This sweeper is going to keep an eye on the Page model
+
+  # If our sweeper detects that a Page was created call this
+  def after_create(page)
+    expire_cache_for(page)
+  end
+  
+  # If our sweeper detects that a Page was updated call this
+  def after_update(page)
+    expire_cache_for(page)
+  end
+  
+  # If our sweeper detects that a Page was deleted call this
+  def after_destroy(page)
+    expire_cache_for(page)
+  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')
+
+    # Also expire the show pages, in case we just edited/deleted a page
+    expire_action(:controller => 'pages', :action => 'show', :id => record.to_param)
+  end
+end

data/app/controllers/pages_controller.rb

@@ -0,0 +1,70 @@
+class PagesController < BaseController
+  uses_tiny_mce do
+    {:only => [:new, :edit, :update, :create ], :options => configatron.default_mce_options}
+  end
+
+  cache_sweeper :page_sweeper, :only => [:create, :update, :destroy]
+  caches_action :show, :if => Proc.new{|c| c.cache_action? }
+
+  def cache_action?
+    !logged_in? && controller_name.eql?('pages')
+  end 
+
+  before_filter :login_required, :only => [:index, :new, :edit, :update, :destroy, :create, :preview]
+  before_filter :require_moderator, :only => [:index, :new, :edit, :update, :destroy, :create, :preview]
+
+  def index
+    @pages = Page.unscoped.order('created_at DESC').page(params[:page])
+  end
+
+  def preview
+    @page = Page.find(params[:id])
+    render :action => :show
+  end
+
+  def show
+    @page = Page.live.find(params[:id])
+    unless logged_in? || @page.page_public
+      flash[:error] = :page_not_public_warning.l
+      redirect_to :controller => 'sessions', :action => 'new'      
+    end
+  rescue
+    flash[:error] = :page_not_found.l
+    redirect_to home_path
+  end
+
+  def create
+    @page = Page.new(params[:page])
+    if @page.save
+      flash[:notice] = :page_was_successfully_created.l
+      redirect_to admin_pages_path
+    else
+      render :action => :new
+    end
+  end
+
+  def update
+    if @page.update_attributes(params[:page])
+      flash[:notice] = :page_was_successfully_updated.l
+      redirect_to admin_pages_path
+    else
+      render :action => :edit
+    end
+  end
+
+  def destroy
+    @page.destroy
+    flash[:notice] = :page_was_successfully_deleted.l
+    redirect_to admin_pages_path
+  end
+
+  private
+  
+  def require_moderator
+    @page ||= Page.find(params[:id]) if params[:id]
+    unless admin? || moderator?
+      redirect_to :controller => 'sessions', :action => 'new' and return false
+    end
+  end
+
+end

data/app/controllers/password_resets_controller.rb

@@ -0,0 +1,52 @@
+class PasswordResetsController < BaseController
+
+  before_filter :require_no_user
+  before_filter :load_user_using_perishable_token, :only => [ :edit, :update ]
+
+  def new
+  end
+
+  def create
+    @user = User.find_by_email(params[:email])
+    if @user
+      @user.deliver_password_reset_instructions!
+
+      flash[:info] = :your_password_reset_instructions_have_been_emailed_to_you.l      
+
+      redirect_to login_path
+    else
+      flash[:error] = :sorry_we_dont_recognize_that_email_address.l      
+
+      render :action => :new
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    @user.password = params[:password]
+    @user.password_confirmation = params[:password_confirmation]
+
+    if @user.save
+      flash[:notice] = :your_changes_were_saved.l
+
+      redirect_to dashboard_user_path(@user)
+    else
+      flash[:error] = @user.errors.full_messages.to_sentence
+      render :action => :edit
+    end
+  end
+
+
+  private
+
+  def load_user_using_perishable_token
+    @user = User.find_using_perishable_token(params[:id])
+    unless @user
+      flash[:error] = :an_error_occurred.l
+      redirect_to login_path
+    end
+  end
+
+end

data/app/controllers/photo_manager_controller.rb

@@ -0,0 +1,11 @@
+class PhotoManagerController < BaseController
+  include Viewable
+  before_filter :login_required
+  before_filter :find_user
+  before_filter :require_current_user
+  
+  def index
+    @albums = current_user.albums.order('id DESC').page(params[:page_albums])
+    @photos_no_albums = current_user.photos.where('album_id IS NULL').order('id DESC').page(params[:page])
+  end
+end