gluttonberg-core 2.5

data/app/controllers/gluttonberg/admin/settings/users_controller.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Settings
+      class UsersController < Gluttonberg::Admin::BaseController
+        before_filter :find_user, :only => [:delete, :edit, :update, :destroy]
+        before_filter :authorize_user , :except => [:edit , :update]
+        record_history :@user , :first_name
+
+        def index
+          unless current_user.super_admin? || current_user.admin?
+            redirect_to :action => "edit" , :id => current_user.id
+          end
+          if current_user.super_admin?
+            unless params[:query].blank?
+              @users = User.order(get_order).where("first_name LIKE '%#{params[:query]}%' OR last_name LIKE '%#{params[:query]}%' OR email LIKE '%#{params[:query]}%' OR bio LIKE '%#{params[:query]}%' " )
+            else
+              @users = User.order(get_order)
+            end
+          else
+            unless params[:query].blank?
+              @users = User.order(get_order).where("role != 'super_admin' AND (first_name LIKE '%#{params[:query]}%' OR last_name LIKE '%#{params[:query]}%' OR email LIKE '%#{params[:query]}%' OR bio LIKE '%#{params[:query]}%' )" )
+            else
+              @users = User.order(get_order).where( ["role != ?" , "super_admin"])
+            end
+          end
+
+          @users = @users.paginate(:page => params[:page] , :per_page => Gluttonberg::Setting.get_setting("number_of_per_page_items") )
+        end
+
+        def new
+          @user = User.new
+        end
+
+        def create
+          role = params[:user].delete(:role) unless params[:user].blank?
+          @user = User.new(params[:user])
+          @user.role = role if current_user.user_valid_roles(@user).include?(role)
+          if @user.save
+            flash[:notice] = "Account registered!"
+            redirect_to admin_users_path
+          else
+            render :action => :new
+          end
+        end
+
+        def edit
+        end
+
+        def update
+          role = params[:user].delete(:role) unless params[:user].blank?
+          @user.role = role if current_user.user_valid_roles(@user).include?(role)
+          if @user.update_attributes(params[:user])
+            flash[:notice] = "Account updated!"
+            if current_user.super_admin? || current_user.admin?
+              redirect_to  admin_users_path
+            else
+              redirect_to  :action => :edit
+            end
+          else
+            flash[:notice] = "Failed to save account changes!"
+            render :action => :edit
+          end
+        end
+
+        def delete
+          display_delete_confirmation(
+            :title      => "Delete “#{@user.email}” user?",
+            :url        => admin_user_path(@user),
+            :return_url => admin_users_path
+          )
+        end
+
+        def destroy
+          if @user.destroy
+            flash[:notice] = "Account deleted!"
+            redirect_to admin_users_path
+          else
+            flash[:error] = "There was an error deleting the account."
+            redirect_to admin_users_path
+          end
+        end
+
+       private
+          def find_user
+            if current_user.super_admin?
+             @user = User.find(params[:id])
+            elsif current_user.admin?
+              @user = User.find(params[:id])
+              if @user.super_admin?
+                @user = nil
+              end
+            else
+              @user = User.find(params[:id])
+              unless @user.id == current_user.id
+                @user =  nil
+              end
+            end
+            raise ActiveRecord::RecordNotFound  unless @user
+          end
+
+          def authorize_user
+            authorize! :manage, User
+          end
+
+      end
+    end
+  end
+end

data/app/controllers/gluttonberg/admin/user_sessions_controller.rb

@@ -0,0 +1,30 @@
+module Gluttonberg
+  module Admin
+    class UserSessionsController < Gluttonberg::Admin::BaseController
+      layout 'bare'
+
+      skip_before_filter :require_user, :only => [:new, :create]
+      skip_before_filter :require_backend_access, :only => [:new, :create]
+
+      def new
+        @user_session = UserSession.new
+      end
+
+      def create
+        @user_session = UserSession.new(params[:user_session])
+        if @user_session.save
+          flash[:notice] = "Login successful!"
+          redirect_back_or_default admin_root_path
+        else
+          render :action => :new
+        end
+      end
+
+      def destroy
+        current_user_session.destroy
+        flash[:notice] = "Logout successful!"
+        redirect_back_or_default admin_root_path
+      end
+    end
+  end
+end

data/app/controllers/gluttonberg/public/articles_controller.rb

@@ -0,0 +1,70 @@
+module Gluttonberg
+  module Public
+    class ArticlesController <   Gluttonberg::Public::BaseController
+      
+      def index
+        @blog = Gluttonberg::Blog.published.first(:conditions => {:slug => params[:blog_id]}, :include => [:articles])
+        raise ActiveRecord::RecordNotFound.new if @blog.blank?
+        @articles = @blog.articles.published
+        
+         respond_to do |format|
+           format.html
+           format.rss { render :layout => false }
+        end
+      end
+  
+      def show
+        
+        @blog = Gluttonberg::Blog.published.first(:conditions => {:slug => params[:blog_id]})
+        
+        if @blog.blank?
+          @blog = Gluttonberg::Blog.published.first(:conditions => {:previous_slug => params[:blog_id]})
+          
+          unless @blog.blank?
+             redirect_to blog_article_path(:blog_id => @blog.slug , :id => params[:id]) , :status => 301
+             return
+          end
+        end
+        
+        raise ActiveRecord::RecordNotFound.new if @blog.blank?
+        @article = Gluttonberg::Article.published.first(:conditions => {:slug => params[:id], :blog_id => @blog.id})
+        if @article.blank?
+          @article = Gluttonberg::Article.published.first(:conditions => {:previous_slug => params[:id], :blog_id => @blog.id})
+          unless @article.blank?
+             redirect_to blog_article_path(:blog_id => @blog.slug , :id => @article.slug) , :status => 301
+             return
+          end
+        end
+        
+        raise ActiveRecord::RecordNotFound.new if @article.blank?
+        @article.load_localization(env['gluttonberg.locale'])
+        @comments = @article.comments.where(:approved => true)
+        @comment = Comment.new(:subscribe_to_comments => true)
+      end
+      
+      def tag
+        @articles = Article.tagged_with(params[:tag]).includes(:blog).published 
+        @tags = Gluttonberg::Article.published.tag_counts_on(:tag)   
+      end
+      
+      def unsubscribe
+        @subscription = CommentSubscription.find(:first , :conditions => {:reference_hash => params[:reference] })
+        unless @subscription.blank?
+          @subscription.destroy
+          flash[:notice] = "You are successfully unsubscribe from comments of \"#{@subscription.article.title}\""
+          redirect_to blog_article_url(@subscription.article.blog.slug, @subscription.article.slug)
+        end
+      end
+      
+      def preview
+        @blog = Gluttonberg::Blog.first(:conditions => {:slug => params[:blog_id]})
+        raise ActiveRecord::RecordNotFound.new if @blog.blank?
+        @article = Gluttonberg::Article.first(:conditions => {:slug => params[:article_id], :blog_id => @blog.id})
+        @article.load_localization(Locale.where(params[:locale_id]).first)
+        raise ActiveRecord::RecordNotFound.new if @article.blank?
+        render :show
+      end
+  
+    end
+  end
+end

data/app/controllers/gluttonberg/public/base_controller.rb

@@ -0,0 +1,169 @@
+# This Class is intended to be used to integrate an arbitrary controller into
+# the Gluttonberg front end. It provides access to the locale/dialect processing,
+# templating, page collections for generating navigations and injects a bunch of
+# other useful helpers.
+
+
+class Gluttonberg::Public::BaseController < ActionController::Base
+    # The included hook is used to create a bunch of class-ivars, which are used to
+    # store various configuration options.
+    #
+    # It also installs before and after hooks that have been declared elsewhere
+    # in this module.
+    
+    attr_accessor :page, :locale  
+    before_filter :retrieve_locale , :rails_locale
+        
+    layout "public"
+    
+    helper_method :current_user_session, :current_user , :current_member_session , :current_member , :current_localization_slug
+    
+    if Rails.env == "production"    
+      rescue_from ActionView::MissingTemplate, :with => :not_found
+      rescue_from ActiveRecord::RecordNotFound, :with => :not_found
+      rescue_from ActionController::RoutingError, :with => :not_found
+      rescue_from CanCan::AccessDenied, :with => :access_denied
+    end
+    
+    before_filter :verify_site_access    
+    
+  protected
+    
+    def verify_site_access
+      unless action_name == "restrict_site_access"
+        setting = Gluttonberg::Setting.get_setting("restrict_site_access")
+        if !setting.blank? && cookies[:restrict_site_access] != "allowed"
+          if env['gluttonberg.page'].blank?
+            redirect_to restrict_site_access_path(:return_url => request.url)
+          else
+            default_localization = Gluttonberg::PageLocalization.find(:first , :conditions => { :page_id => env['gluttonberg.page'].id , :locale_id => Gluttonberg::Locale.first_default.id } )
+            redirect_to restrict_site_access_path(:return_url => default_localization.public_path)
+          end  
+        end
+      end  
+    end
+    
+    def rails_locale
+      if env['gluttonberg.locale'].blank?
+        I18n.locale = I18n.default_locale
+      else
+        I18n.locale = env['gluttonberg.locale'].slug || I18n.default_locale
+      end
+      
+    end
+    def current_user_session
+      return @current_user_session if defined?(@current_user_session)
+      @current_user_session = UserSession.find
+    end
+
+    def current_user
+      return @current_user if defined?(@current_user)
+      @current_user = current_user_session && current_user_session.record
+    end
+
+    def require_user
+      unless current_user
+        store_location
+        flash[:error] = "You must be logged in to access this page"
+        redirect_to login_url
+        return false
+      end
+      true
+    end
+    
+    def current_member_session
+      return @current_member_session if defined?(@current_member_session)
+      @current_member_session = MemberSession.find
+    end
+
+    def current_member
+      return @current_member if defined?(@current_member)
+      @current_member = current_member_session && current_member_session.record
+      if !@current_member.blank? && @current_member.can_login?
+      else
+         current_member_session.destroy unless current_member_session.blank?
+         @current_member = nil
+      end  
+      @current_member
+    end
+
+    def require_member
+      if current_member.blank?
+        store_location
+        flash[:error] = "You must be logged in to access this page"
+        redirect_to member_login_url
+        return false
+      elsif current_member.profile_confirmed != true && controller_name != "members"
+        flash[:error] = "Your account has not been verified. Please check your email for your verification link. If you did not receive your verification email, Please click <a href='#{member_resend_confirmation_path}' >here</a> to resend it."
+        redirect_to member_profile_url
+        return false
+      end
+      true
+    end
+    
+    def is_members_enabled 
+      unless Gluttonberg::Member.enable_members == true
+        raise ActiveRecord::RecordNotFound
+      end  
+    end
+    
+    def require_super_admin_user
+      return false unless require_user
+      
+      unless current_user.super_admin?
+        store_location
+        flash[:notice] = "You dont have privilege to access this page"
+        redirect_to admin_login_url
+        return false
+      end
+    end
+    
+    def store_location
+      @page = env['gluttonberg.page']
+      if @page.blank?
+        session[:return_to] = request.url
+      else
+        session[:return_to] = @page.public_path
+      end 
+    end
+
+    def redirect_back_or_default(default)
+      redirect_to(session[:return_to] || default)
+      session[:return_to] = nil
+    end
+      
+    def retrieve_locale
+      @locale = env['gluttonberg.locale']
+    end
+    
+    # Exception handlers
+    def not_found
+      render :layout => "bare" , :template => 'gluttonberg/public/exceptions/not_found.html.haml' , :status => 404
+    end
+    
+    def access_denied
+      render :layout => "bare" , :template => 'gluttonberg/public/exceptions/access_denied.html.haml'
+    end
+
+    # handle NotAcceptable exceptions (406)
+    def not_acceptable
+      render :layout => "bare" , :template => 'gluttonberg/public/exceptions/not_acceptable.html.haml'
+    end
+    
+    def internal_server_error
+      render :layout => "bare" , :template => 'gluttonberg/public/exceptions/internal_server_error.html.haml'
+    end
+    
+    def current_localization_slug
+       if @locale
+         @locale.slug
+       else
+         Gluttonberg::Locale.first_default.slug
+       end
+    end
+
+    def localized_text(english , chineese)
+      (current_localization_slug == "cn" ? chineese : english ) 
+    end
+
+end

data/app/controllers/gluttonberg/public/blogs_controller.rb

@@ -0,0 +1,44 @@
+module Gluttonberg
+  module Public
+    class BlogsController <  Gluttonberg::Public::BaseController
+  
+      def index
+        if Gluttonberg::Blog.published.all.size == 0
+          redirect_to "/"
+        elsif Gluttonberg::Blog.published.all.size == 1
+          blog = Gluttonberg::Blog.published.first
+          if Gluttonberg.localized?
+            redirect_to blog_path(current_localization_slug , blog.slug)
+          else
+            redirect_to blog_path(:id =>blog.slug)
+          end  
+        else
+          @blogs = Gluttonberg::Blog.published.all
+        end
+      end
+  
+      def show
+        @blog = Gluttonberg::Blog.published.first(:conditions => {:slug => params[:id]}, :include => [:articles])
+        
+        if @blog.blank?
+          @blog = Gluttonberg::Blog.published.first(:conditions => {:previous_slug => params[:id]})
+          
+          unless @blog.blank?
+             redirect_to blog_path(:id => @blog.slug) , :status => 301
+             return
+          end
+        end
+        
+        raise ActiveRecord::RecordNotFound.new if @blog.blank?
+        @articles = @blog.articles.published
+        @tags = Gluttonberg::Article.published.tag_counts_on(:tag)
+        respond_to do |format|
+           format.html
+           format.rss { render :layout => false }
+        end
+        
+      end
+  
+    end
+  end
+end

data/app/controllers/gluttonberg/public/comments_controller.rb

@@ -0,0 +1,45 @@
+module Gluttonberg
+  module Public
+    class CommentsController <  Gluttonberg::Public::BaseController
+  
+      def create
+        @blog = Gluttonberg::Blog.first(:conditions => {:slug => params[:blog_id]})
+        @article = Gluttonberg::Article.first(:conditions => {:slug => params[:article_id], :blog_id => @blog.id})
+        @comment = @article.comments.new(params[:comment].merge(:blog_slug => params[:blog_id]))
+        @comment.author_id = current_member.id if current_member
+        if @comment.save
+          if Setting.get_setting("comment_notification") == "Yes" || @blog.moderation_required == true
+            User.all_super_admin_and_admins.each do |user|
+              Notifier.comment_notification_for_admin(user , @article , @comment).deliver
+            end
+          end
+          
+          @subscription = CommentSubscription.find(:first , :conditions => {:article_id => @article.id , :author_email => @comment.writer_email })
+          if @comment.subscribe_to_comments == "1" && @subscription.blank?
+            @subscription = CommentSubscription.create( {:article_id => @article.id , :author_email => @comment.writer_email , :author_name => @comment.writer_name } )
+          elsif (@comment.subscribe_to_comments.blank? || @comment.subscribe_to_comments == "0")  && !@subscription.blank?
+            #unsubscribe
+            @subscription.destroy 
+          end
+        else
+          
+        end
+        if Gluttonberg.localized?
+          redirect_to blog_article_path(current_localization_slug , @blog.slug, @article.slug)
+        else
+          redirect_to blog_article_path(:blog_id =>  @blog.slug, :id => @article.slug)
+        end
+      end
+  
+      private 
+        def current_localization_slug
+           if @locale
+             @locale.slug
+           else
+             nil
+           end
+        end
+    end
+    
+  end
+end

data/app/controllers/gluttonberg/public/flag_controller.rb

@@ -0,0 +1,45 @@
+module Gluttonberg
+  module Public
+    class FlagController <  Gluttonberg::Public::BaseController
+      
+      def new
+        model = nil
+        if params[:flaggable_type].include?("Gluttonberg::")
+          model = Gluttonberg.const_get(params[:flaggable_type][13..-1])
+        else  
+          model = Kernel.const_get(params[:flaggable_type])
+        end  
+        @flaggable = model.find(params[:flaggable_id])
+        
+      end
+  
+      def create
+        flag = current_user.flags.create params[:flag]
+        flash[:notice] = if flag.new_record?
+          "You already flagged this content!"
+        else # success
+          "Content has been flagged!"
+        end
+
+
+        respond_to do |format|# note: you'll need to ensure that this route exists
+          format.html {
+            url = "" 
+            begin
+              if flag.flaggable.respond_to?(:commentable)
+                url = polymorphic_path(flag.flaggable.commentable)
+              else
+                url = polymorphic_path(flag.flaggable)
+              end  
+              flag.update_attributes(:url => url)
+              redirect_to url
+            rescue => e
+            end
+          }
+          # format.js # render some js trickery
+        end
+      end
+  
+    end
+  end
+end

data/app/controllers/gluttonberg/public/gallery_controller.rb

@@ -0,0 +1,2 @@
+class GalleryController < ApplicationController
+end

data/app/controllers/gluttonberg/public/member_password_resets_controller.rb

@@ -0,0 +1,55 @@
+module Gluttonberg
+  module Public
+    class MemberPasswordResetsController < Gluttonberg::Public::BaseController  
+      skip_before_filter :require_member
+      before_filter :load_member_using_perishable_token, :only => [:edit, :update]
+      
+      layout 'public'
+      
+      def new
+      end
+      
+      def create
+        @member = Member.find_by_email(params[:gluttonberg_member][:email])
+        if @member
+          @member.deliver_password_reset_instructions!(current_localization_slug)
+          flash[:notice] = "Instructions to reset your password have been emailed to you. " +
+          "Please check your email."
+          redirect_to root_path
+        else
+          flash[:notice] = "No member was found with that email address"
+          redirect_to root_path
+        end
+      end
+      
+      def edit
+        
+      end
+      
+      def update
+        @member.password = params[:gluttonberg_member][:password]
+        @member.password_confirmation = params[:gluttonberg_member][:password_confirmation]
+        if @member.save
+          flash[:notice] = "Password successfully updated"
+          redirect_to root_path
+        else
+          render :edit
+        end
+      end
+      
+      private
+      
+        def load_member_using_perishable_token
+          @member = Member.find_using_perishable_token(params[:id])
+          unless @member
+            flash[:notice] = "We're sorry, but we could not locate your account. " +
+            "If you are having issues try copying and pasting the URL " +
+            "from your email into your browser or restarting the " +
+            "reset password process."
+            redirect_to root_path
+          end
+        end
+    
+    end
+  end
+end

data/app/controllers/gluttonberg/public/member_sessions_controller.rb

@@ -0,0 +1,30 @@
+module Gluttonberg
+  module Public
+    class MemberSessionsController < Gluttonberg::Public::BaseController
+      
+      layout 'public'
+      before_filter :is_members_enabled
+      skip_before_filter :require_member, :only => [:new, :create]
+      
+      def new
+        @member_session = MemberSession.new
+      end
+  
+      def create
+        @member_session = MemberSession.new(params[:member_session])
+        if @member_session.save
+          flash[:notice] = "Login successful!"
+          redirect_back_or_default root_path
+        else
+          render :action => :new
+        end
+      end
+  
+      def destroy
+        current_member_session.destroy
+        flash[:notice] = "Logout successful!"
+        redirect_back_or_default root_path
+      end
+    end
+  end
+end

data/app/controllers/gluttonberg/public/members_controller.rb

@@ -0,0 +1,88 @@
+module Gluttonberg
+  module Public
+    class MembersController < Gluttonberg::Public::BaseController
+      before_filter :is_members_enabled
+      
+      before_filter :require_member , :only => [ :edit, :update, :show ]
+      layout 'public'
+      
+      def new
+        @page_title = "Register"
+        @member = Member.new
+      end
+  
+      def create
+        @member = Member.new(params[:gluttonberg_member])
+        if Member.does_email_verification_required
+          @member.confirmation_key = Digest::SHA1.hexdigest(Time.now.to_s + rand(12341234).to_s)[1..24]
+        else  
+          @member.profile_confirmed = true
+        end
+        if @member && @member.save
+          if Member.does_email_verification_required
+            MemberNotifier.confirmation_instructions(@member.id,current_localization_slug).deliver
+            flash[:notice] = "Please check your email for a confirmation."
+          else
+            flash[:notice] = "Your registration is now complete."
+          end
+          redirect_to root_path
+        else
+          @page_title = "Register"
+          render :new
+        end
+      end
+  
+  
+      def confirm
+        @member = Member.where(:confirmation_key => params[:key]).first
+        if @member
+          @member.profile_confirmed = true
+          @member.save
+          flash[:notice] = "Your registration is now complete."
+          redirect_to root_url
+        else
+          flash[:notice] = "We're sorry, but we could not locate your account. " +
+          "If you are having issues try copying and pasting the URL " +
+          "from your email into your browser."
+          redirect_to root_url
+        end
+      end
+  
+      def resend_confirmation
+        if current_member.confirmation_key.blank?
+          confirmation_key = Digest::SHA1.hexdigest(Time.now.to_s + rand(12341234).to_s)[1..24]
+          current_member.confirmation_key = confirmation_key
+          current_member.save
+        end
+        MemberNotifier.confirmation_instructions(current_member.id,current_localization_slug).deliver if current_member && !current_member.profile_confirmed
+        flash[:notice] = "Please check your email for a confirmation."
+        redirect_to member_profile_url
+      end
+  
+      def update
+        @member = current_member
+        if @member.update_attributes(params[:gluttonberg_member])
+          @member.save
+          if params[:gluttonberg_member][:return_url]
+            redirect_to params[:gluttonberg_member][:return_url]
+          else
+            redirect_to root_path
+          end
+        end
+      end
+  
+      def show
+        @member = current_member
+      end
+  
+      def edit
+        @member = current_member
+      end
+  
+  
+  
+      protected
+  
+    end
+  end
+end