community_engine 2.0.0.beta1

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,34 @@
+# This controller handles the login/logout function of the site.  
+class SessionsController < BaseController
+
+  def index
+    redirect_to :action => "new"
+  end  
+
+  def new
+    redirect_to user_path(current_user) and return if current_user
+    @user_session = UserSession.new
+  end
+
+  def create
+    @user_session = UserSession.new(:login => params[:email], :password => params[:password], :remember_me => params[:remember_me])
+
+    if @user_session.save
+
+      current_user = @user_session.record #if current_user has been called before this, it will ne nil, so we have to make to reset it
+      
+      flash[:notice] = :thanks_youre_now_logged_in.l
+      redirect_back_or_default(dashboard_user_path(current_user))
+    else
+      flash[:notice] = :uh_oh_we_couldnt_log_you_in_with_the_username_and_password_you_entered_try_again.l
+      render :action => :new
+    end
+  end
+
+  def destroy
+    current_user_session.destroy
+    flash[:notice] = :youve_been_logged_out_hope_you_come_back_soon.l
+    redirect_to new_session_path
+  end
+
+end

data/app/controllers/sitemap_controller.rb

@@ -0,0 +1,21 @@
+class SitemapController < BaseController
+  layout false
+  caches_action :index
+
+  def index
+    @users = User.active.select('id, login, updated_at, login_slug')
+    @posts = Post.select('posts.id, posts.user_id, posts.published_as, posts.published_at, users.id, users.login_slug').joins(:user)   #"LEFT JOIN users ON users.id = posts.user_id")
+
+    @categories = Category.find(:all)
+  
+    respond_to do |format|
+      format.html {
+        render :layout => 'application'
+      }
+      format.xml 
+    end
+  end
+  
+  
+  
+end

data/app/controllers/statistics_controller.rb

@@ -0,0 +1,34 @@
+class StatisticsController < BaseController
+  before_filter :login_required
+  before_filter :admin_required
+
+  def index
+    @total_users = User.count(:conditions => ['activated_at IS NOT NULL'])
+    @unactivated_users = User.count(:conditions => ['activated_at IS NULL'])
+
+    @yesterday_new_users = find_new_users(1.day.ago.midnight, Date.today.midnight)
+    @today_new_users = find_new_users(Date.today.midnight, Date.today.tomorrow.midnight)  
+
+    @active_users_count = Activity.count(:all, :group => "user_id", :conditions => ["created_at > ?", 1.month.ago]).size
+
+    @active_users = User.find_by_activity({:since => 1.month.ago})
+    
+    @percent_reporting_zip = (User.count(:all, :conditions => "zip IS NOT NULL") / @total_users.to_f)*100
+    
+    users_reporting_gender = User.count(:all, :conditions => "gender IS NOT NULL")
+    @percent_male = (User.count(:all, :conditions => ['gender = ?', User::MALE ]) / users_reporting_gender.to_f) * 100
+    @percent_female = (User.count(:all, :conditions => ['gender = ?', User::FEMALE] ) / users_reporting_gender.to_f) * 100        
+    
+    @featured_writers = User.find_featured
+
+    @posts = Post.find(:all, :conditions => ['? <= posts.published_at AND posts.published_at <= ? AND users.featured_writer = ?', Time.now.beginning_of_month, (Time.now.end_of_month + 1.day), true], :include => :user)        
+  end  
+
+      
+  protected
+    def find_new_users(from, to, limit= nil)
+      User.active.where(:created_at => from..to)
+    end
+  
+
+end

data/app/controllers/taggable_sweeper.rb

@@ -0,0 +1,38 @@
+class TaggableSweeper < ActionController::Caching::Sweeper
+  observe User, Post, Clipping, Photo # This sweeper is going to keep an eye on taggable models
+
+  # If our sweeper detects that a taggable (User) was activated 
+  def after_activate(taggable)
+    expire_cache_for(taggable)
+  end
+
+  # If our sweeper detects that a taggable was created
+  def after_create(taggable)
+    expire_cache_for(taggable)
+  end
+
+  # If our sweeper detects that a photo was uploaded
+  def after_swfupload(photo)
+    expire_cache_for(taggable)    
+  end
+  
+  # If our sweeper detects that a taggable was updated 
+  def after_update(taggable)
+    expire_cache_for(taggable)
+  end
+  
+  # If our sweeper detects that a taggable was deleted
+  def after_destroy(taggable)
+    expire_cache_for(taggable)
+  end
+          
+  private
+  def expire_cache_for(record)
+    # Expire the tag show pages
+    record.tags.each do |tag|
+      expire_action({:action=>"show", :controller=>"tags", :id => tag.id})      
+    end
+  end
+  
+  
+end

data/app/controllers/tags_controller.rb

@@ -0,0 +1,104 @@
+class TagsController < BaseController
+  before_filter :login_required, :only => [:manage, :edit, :update, :destroy]
+  before_filter :admin_required, :only => [:manage, :edit, :update, :destroy]
+  skip_before_filter :verify_authenticity_token, :only => 'auto_complete_for_tag_name'
+
+  caches_action :show, :cache_path => Proc.new { |controller| controller.send(:tag_url, controller.params[:id]) }, :if => Proc.new{|c| c.cache_action? }
+  def cache_action?
+    !logged_in? && params[:type].blank?
+  end  
+
+  def auto_complete_for_tag_name
+    @tags = Tag.find(:all, :limit => 10, :conditions => [ 'LOWER(name) LIKE ?', '%' + (params[:id] || params[:tag_list]) + '%' ])
+    render :inline => "<%= auto_complete_result(@tags, 'name') %>"
+  end
+  
+  def index  
+    @tags = popular_tags(100)
+
+    @user_tags = popular_tags(75, 'User')
+    
+    @post_tags = popular_tags(75, 'Post')
+
+    @photo_tags = popular_tags(75, 'Photo')
+
+    @clipping_tags = popular_tags(75, 'Clipping')  
+  end
+  
+  def manage
+    @search = Tag.search(params[:search])
+    @search.order ||= :ascend_by_name
+    @search.meta_sort ||= 'name.asc'    
+    @tags = @search.page(params[:page]).per(100)
+  end
+  
+
+  def edit
+    @tag = Tag.find_by_name(URI::decode(params[:id]))
+  end
+
+  def update
+    @tag = Tag.find_by_name(URI::decode(params[:id]))
+    
+    respond_to do |format|
+      if @tag.update_attributes(params[:tag])
+        flash[:notice] = :tag_was_successfully_updated.l
+        format.html { redirect_to admin_tags_url }
+        format.xml  { render :nothing => true }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @tag.errors.to_xml }        
+      end
+    end
+  end
+
+  def destroy
+    @tag = Tag.find_by_name(URI::decode(params[:id]))
+    @tag.destroy
+    
+    respond_to do |format|
+      format.html { 
+        flash[:notice] = :tag_was_successfully_deleted.l
+        redirect_to admin_tags_url
+      }
+      format.xml  { render :nothing => true }
+    end
+  end
+
+  def show
+    tag_names = URI::decode(params[:id])
+    
+    @tags = Tag.find(:all, :conditions => [ 'name IN (?)', TagList.from(tag_names) ] )
+    if @tags.nil? || @tags.empty?
+      flash[:notice] = :tag_does_not_exists.l_with_args(:tag => tag_names)
+      redirect_to :action => :index and return
+    end
+    @related_tags = @tags.first.related_tags
+    @tags_raw = @tags.collect { |t| t.name } .join(',')
+
+    if params[:type]
+      case params[:type]
+        when 'Post', 'posts'
+          @pages = @posts = Post.recent.tagged_with(tag_names, :match_all => true).page(params[:page]).per(20)
+          @photos, @users, @clippings = [], [], []
+        when 'Photo', 'photos'
+          @pages = @photos = Photo.recent.tagged_with(tag_names, :match_all => true).page(params[:page]).per(30)
+          @posts, @users, @clippings = [], [], []
+        when 'User', 'users'
+          @pages = @users = User.recent.tagged_with(tag_names, :match_all => true).page(params[:page]).per(30)
+          @posts, @photos, @clippings = [], [], []
+        when 'Clipping', 'clippings'
+          @pages = @clippings = Clipping.recent.tagged_with(tag_names, :match_all => true).page(params[:page]).per(10)
+          @posts, @photos, @users = [], [], []
+      else
+        @clippings, @posts, @photos, @users = [], [], [], []
+      end
+    else
+      @posts = Post.recent.limit(5).tagged_with(tag_names, :match_all => true)
+      @photos = Photo.recent.limit(10).tagged_with(tag_names, :match_all => true)
+      @users = User.recent.limit(10).tagged_with(tag_names, :match_all => true)
+      @clippings = Clipping.recent.limit(10).tagged_with(tag_names, :match_all => true)
+    end
+  end
+
+end

data/app/controllers/theme_controller.rb

@@ -0,0 +1,60 @@
+class ThemeController < BaseController
+  def stylesheets
+    render_theme_item(:stylesheets, params[:filename], 'text/css; charset=utf-8')
+  end
+
+  def javascript
+    render_theme_item(:javascript, params[:filename], 'text/javascript; charset=utf-8')
+  end
+
+  def images
+    render_theme_item(:images, params[:filename])
+  end
+
+  def error
+    render :nothing => true, :status => 404
+  end
+
+  private
+
+  def render_theme_item(type, file, mime = nil)
+
+    mime ||= mime_for(file)
+    if file.split(%r{[\\/]}).include?("..")
+      return (render :text => "Not Found", :status => 404)
+    end
+
+    src = "#{Rails.root}/themes/#{configatron.theme}" + "/#{type}/#{file}"
+    return (render :text => "Not Found", :status => 404) unless File.exists? src
+
+    if perform_caching
+      dst = "#{page_cache_directory}/#{type}/theme/#{file}"
+      FileUtils.makedirs(File.dirname(dst))
+      FileUtils.cp(src, "#{dst}.#{$$}")
+      FileUtils.ln("#{dst}.#{$$}", dst) rescue nil
+      FileUtils.rm("#{dst}.#{$$}", :force => true)
+    end
+    send_file(src, :type => mime, :disposition => 'inline', :stream => true)
+  end
+
+  def mime_for(filename)
+    case filename && filename.downcase
+    when /\.js$/
+      'text/javascript'
+    when /\.css$/
+      'text/css'
+    when /\.gif$/
+      'image/gif'
+    when /(\.jpg|\.jpeg)$/
+      'image/jpeg'
+    when /\.png$/
+      'image/png'
+    when /\.swf$/
+      'application/x-shockwave-flash'
+    else
+      'application/binary'
+    end
+  end
+
+
+end

data/app/controllers/topics_controller.rb

@@ -0,0 +1,122 @@
+class TopicsController < BaseController
+  before_filter :find_forum_and_topic, :except => :index
+  before_filter :login_required, :except => [:index, :show]
+
+  uses_tiny_mce do
+    {:only => [:show, :new, :create, :update], :options => configatron.default_mce_options}
+  end
+
+  def index
+    @forum = Forum.find(params[:forum_id])    
+    respond_to do |format|
+      format.html { redirect_to forum_path(params[:forum_id]) }
+      format.xml do
+        @topics = @forum.topics.find(:all, :order => 'sticky desc, replied_at desc', :limit => 25)
+        render :xml => @topics.to_xml
+      end
+    end
+  end
+
+  def new
+    @topic = Topic.new(params[:topic])
+    @topic.body = params[:topic][:body] if params[:topic] 
+  end
+  
+  def show
+    respond_to do |format|
+      format.html do
+        # see notes in base_controller.rb on how this works
+        current_user.update_last_seen_at if logged_in?
+        # keep track of when we last viewed this topic for activity indicators
+        (session[:topics] ||= {})[@topic.id] = Time.now.utc if logged_in?
+        # authors of topics don't get counted towards total hits
+        @topic.hit! unless logged_in? and @topic.user == current_user
+
+        @posts = @topic.sb_posts.recent.includes(:user).page(params[:page]).per(25)
+
+        @voices = @posts.map(&:user)
+        @voices.compact.uniq!
+        @post   = SbPost.new(params[:post])
+      end
+      format.xml do
+        render :xml => @topic.to_xml
+      end
+      format.rss do
+        @posts = @topic.sb_posts.recent.limit(25)
+        render :action => 'show.xml.builder', :layout => false
+      end
+    end
+  end
+  
+  def create
+    # this is icky - move the topic/first post workings into the topic model?
+    Topic.transaction do
+      @topic  = @forum.topics.new(params[:topic])
+      assign_protected
+      @post   = @topic.sb_posts.new(params[:topic])
+      @post.topic=@topic
+      @post.user = current_user
+      # only save topic if post is valid so in the view topic will be a new record if there was an error
+      @topic.tag_list = params[:tag_list] || ''
+      @topic.save if @post.valid?
+      @post.save
+    end
+    if !@topic.valid?
+      respond_to do |format|
+        format.html { 
+          render :action => 'new' and return
+        }
+      end
+    else
+      respond_to do |format|
+        format.html { 
+          redirect_to forum_topic_path(@forum, @topic) 
+        }
+        format.xml  { 
+          head :created, :location => forum_topic_url(:forum_id => @forum, :id => @topic, :format => :xml) 
+        }
+      end
+    end
+  end
+  
+  def update
+    @topic.attributes = params[:topic]
+    assign_protected
+    @topic.tag_list = params[:tag_list] || ''
+    @topic.save!
+    respond_to do |format|
+      format.html { redirect_to forum_topic_path(@forum, @topic) }
+      format.xml  { head 200 }
+    end
+  end
+  
+  def destroy
+    @topic.destroy
+    flash[:notice] = :topic_deleted.l_with_args(:topic => CGI::escapeHTML(@topic.title)) 
+    respond_to do |format|
+      format.html { redirect_to forum_path(@forum) }
+      format.xml  { head 200 }
+    end
+  end
+  
+  protected
+    def assign_protected
+      @topic.user     = current_user if @topic.new_record?
+      # admins and moderators can sticky and lock topics
+      return unless admin? or current_user.moderator_of?(@topic.forum)
+      @topic.sticky, @topic.locked = params[:topic][:sticky], params[:topic][:locked] 
+      # only admins can move
+      return unless admin?
+      @topic.forum_id = params[:topic][:forum_id] if params[:topic][:forum_id]
+    end
+    
+    def find_forum_and_topic
+      @forum = Forum.find(params[:forum_id])
+      @topic = @forum.topics.find(params[:id]) if params[:id]
+    end
+
+    #overide in your app
+    def authorized?
+      %w(new create).include?(action_name) || @topic.editable_by?(current_user)
+    end
+end