westarete-skylinecms 3.0.8.20100329

data/app/controllers/skyline/content_items_controller.rb

@@ -0,0 +1,14 @@
+class Skyline::ContentItemsController < Skyline::ApplicationController
+  def new
+    return unless request.xhr?
+    render :update do |page|
+      if params[:content_item_type].present?
+        @content_item_class = params[:content_item_type].constantize
+        page.replace_html("section-#{params[:guid]}-content-item-id", :partial => "content_item", :locals => {:guid => params[:guid], :sectionable => Skyline::Sections::ContentItemSection.new})
+      else
+        page.replace_html("section-#{params[:guid]}-content-item-id", :text => "")
+        page << "var myFx = new Fx.Scroll(\"contentEditPanel\").toBottom();"        
+      end
+    end
+  end
+end

data/app/controllers/skyline/content_sections_controller.rb

@@ -0,0 +1,15 @@
+class Skyline::ContentSectionsController < Skyline::ApplicationController
+  def new
+    return unless request.xhr?
+    render :update do |page|
+      if params[:taggable_type].present?
+        taggable = params[:taggable_type].constantize
+        @tags = taggable.available_tags
+        page.replace("section-#{params[:guid]}-tags", :partial => "tags", :locals => {:guid => params[:guid], :sectionable => taggable.new})
+      else
+        page.replace("section-#{params[:guid]}-tags", :text => "")
+        page << "var myFx = new Fx.Scroll(\"contentEditPanel\").toBottom();"        
+      end
+    end
+  end
+end

data/app/controllers/skyline/link_section_links_controller.rb

@@ -0,0 +1,14 @@
+class Skyline::LinkSectionLinksController < Skyline::ApplicationController
+  def new
+    return unless request.xhr?
+    render :update do |page|
+      link = Skyline::LinkSectionLink.new
+      link_guid = Guid.new
+      
+      fields_for params[:object_name], link do |sectionable_form|
+        page.insert_html(:bottom, "section-#{params[:guid]}-links", :partial => "form", :locals => {:sectionable_form => sectionable_form, :link => link, :guid => params[:guid], :link_guid => link_guid})
+        page << "linkSectionLinksSortable#{params[:guid].to_s.gsub("-","")}.addItem('link_section_#{link_guid}');"
+      end
+    end
+  end
+end

data/app/controllers/skyline/locales_controller.rb

@@ -0,0 +1,15 @@
+class Skyline::LocalesController < Skyline::ApplicationController
+
+  def show
+    locale = params[:id]
+    unless @locale = I18n.t("tinymce", :locale => (locale || I18n.locale))
+      render :nothing => true, :status => :not_found
+    end
+  end
+  
+  protected
+  
+  def protect?
+    false
+  end
+end

data/app/controllers/skyline/media_dirs_controller.rb

@@ -0,0 +1,56 @@
+class Skyline::MediaDirsController < Skyline::ApplicationController
+
+  layout "skyline/layouts/media"
+  
+  self.default_menu_item = :media_library
+  
+  authorize :create, :by => "media_dir_create"
+  authorize :edit, :update, :by => "media_dir_update"
+  authorize :destroy, :by => "media_dir_delete"
+  
+  def index
+    @media_dirs = Skyline::MediaDir.group_by_parent_id 
+  end
+  
+  def create
+    parent_id = params[:parent_id] || 0        
+    
+    @parent = Skyline::MediaDir.find_by_id(parent_id)
+    if @parent
+      @directory = @parent.subdirectories.build()
+    else
+      @directory = Skyline::MediaDir.new()
+    end
+    @directory.save
+        
+    render :update do |p|
+      p.replace("dirtree", 
+      		:partial => "skyline/media_dirs/index", 
+      		:locals => {:media_dirs => Skyline::MediaDir.group_by_parent_id, :selected_node => @directory})
+    end
+  end
+    
+  def update    
+    media_dir = Skyline::MediaDir.find(params[:id])
+    
+    if params[:skyline_media_dir]
+      media_dir.name = params[:skyline_media_dir][:name] if !params[:skyline_media_dir][:name].blank?
+      media_dir.parent_id = (params[:skyline_media_dir][:parent_id] == "0") ? nil : params[:skyline_media_dir][:parent_id]
+    
+      media_dir.save
+    end
+    
+    render :update do |p|
+      p.replace( "dirtree", :partial => "index", :locals => {:media_dirs => Skyline::MediaDir.group_by_parent_id, :selected_node => media_dir})
+    end
+  end
+  
+  def destroy
+    media_dir = Skyline::MediaDir.find(params[:id])    
+    media_dir.destroy
+    
+    render :update do |p|
+      p.replace( "dirtree", :partial => "index", :locals => {:media_dirs => Skyline::MediaDir.group_by_parent_id, :selected_node => media_dir.directory})
+    end
+  end
+end

data/app/controllers/skyline/media_files_controller.rb

@@ -0,0 +1,87 @@
+class Skyline::MediaFilesController < Skyline::ApplicationController    
+  layout "skyline/layouts/media"
+  # to avoid error 422 on authentication/session management
+  skip_before_filter :verify_authenticity_token, :only => :create
+  
+  self.default_menu_item = :media_library  
+      
+  authorize :create, :by => "media_file_create"
+  authorize :edit, :update, :by => "media_file_update"
+  authorize :destroy, :by => "media_file_delete"
+    
+  def index    
+    media_dir = Skyline::MediaDir.find(params[:media_dir_id])
+    selected_file = params[:selected_file_id].nil? || params[:selected_file_id] == "0" ? nil : Skyline::MediaFile.find(params[:selected_file_id])
+    
+    render :update do |p|
+    	if !params[:listonly]
+    	  p.replace_html("contentHeaderPanel", "<span class=\"content\">#{t(:files_in, :directory => media_dir.name, :scope => [:media_file,:index])}</span>")
+    		p.replace_html("uploadPanel", :partial => "new", :locals => {:media_dir => media_dir})
+    		p.replace_html("metaHeaderPanel", "<span class=\"content directory\">#{media_dir.name}</span>")      
+    		p.replace_html("metaBodyPanel", :partial => "skyline/media_dirs/edit", :locals => {:media_dir => media_dir})
+    	end
+    	    	
+    	p.replace_html("filelist", :partial => "index", :locals => {:media_dir => media_dir, :show_meta_data => params[:show_meta_data], :selected_file => selected_file})
+      
+    end
+  end
+  
+  def create
+    @parent = Skyline::MediaDir.find_by_id(params[:media_dir_id])
+    
+    @media_file = Skyline::MediaFile.new(:name => params[:Filename], :parent_id => params[:media_dir_id], :data => params[:Filedata])
+    @parent.files << @media_file if @parent
+    
+    if @media_file.save
+      render :json => {:result => "success"}
+    else
+      render :json => {:result => "failed"}
+    end
+    
+  end
+    
+  def edit
+    @tags = Skyline::MediaFile.available_tags   
+    media_file = Skyline::MediaFile.find(params[:id])
+    
+    render :update do |p|
+    	p.replace_html("metaHeaderPanel", :partial => "skyline/media_files/header", :locals => {:media_file => media_file} )      
+      p.replace_html("metaBodyPanel", :partial => "skyline/media_files/edit", :locals => {:media_file => media_file} )      
+    end
+  end
+  
+  def update
+    @tags = Skyline::MediaFile.available_tags   
+    media_file = Skyline::MediaFile.find(params[:id])
+    original_media_file = media_file.clone
+    media_file.attributes = params[:skyline_media_file]
+    
+    @saved = media_file.save
+    
+    render :update do |p|
+      if @saved
+        p.notification :success, t(:success, :scope => [:media_file,:update,:flashes])
+      else
+        p.message :failed, t(:failed, :scope => [:media_file,:update,:flashes])
+      end
+      if original_media_file.directory.id == media_file.directory.id
+        # just a normal edit of the media_file
+      	p.replace_html("filelist", :partial => "index", :locals => {:media_dir => media_file.directory, :selected_file => media_file})
+      else
+        # file was moved to another directory
+      	p.replace_html("filelist", :partial => "index", :locals => {:media_dir => original_media_file.directory})
+      	p.replace_html("metaHeaderPanel", "<span class=\"content folder\">#{original_media_file.directory.name}</span>")      
+        p.replace_html("metaBodyPanel", :partial => "skyline/media_dirs/edit", :locals => {:media_dir => original_media_file.directory})
+      end    
+    end    
+  end
+
+  
+  def destroy
+    media_file = Skyline::MediaFile.find(params[:id])
+    media_file.destroy
+    
+    redirect_to :action=>:index, :media_dir_id=> params[:media_dir_id]
+  end
+      
+end

data/app/controllers/skyline/media_files_data_controller.rb

@@ -0,0 +1,60 @@
+class Skyline::MediaFilesDataController < Skyline::ApplicationController  
+  after_filter :perform_cache, :only => :show
+  
+  self.page_cache_directory = Skyline::MediaCache.cache_path
+  
+  # show
+  # Renders the requested image with specified size parameters and stores the image in the cache. 
+  # If the image is already in the cache then 304 Not Modified is rendered.
+  #
+  # ==== Parameters
+  # size <String> WidthxHeight
+  
+  def show
+    @skip_caching = false
+
+    filename = "#{params[:name]}.#{params[:format]}"
+    
+    @media_file = Skyline::MediaFile.find(:first, :conditions => {:parent_id => params[:media_dir_id], :name => filename})
+    
+    cached_file = File.join(self.page_cache_directory,request.path)    
+    
+    if File.exist?(cached_file)                      
+      response.etag = File.mtime(cached_file)
+          
+      if request.etag_matches?(response.etag)
+        head :not_modified
+      else
+        send_file cached_file, :filename => @media_file.name, :type => @media_file.content_type, :disposition => 'inline', :stream => false, :cache => true
+      end
+      @skip_caching = true
+    else
+      if params[:size].present?
+        size = params[:size].to_s.split("x").map{|v| v.to_i }
+        size = nil if size[0] == @media_file.width && size[1] >= @media_file.height || size[1] == @media_file.height && size[0] >= @media_file.width
+      else
+        size = nil
+      end
+      
+      if size.nil?
+        send_file @media_file.file_path, :filename => @media_file.name, :type => @media_file.content_type, :disposition => 'inline', :cache => true
+        @skip_caching = true
+      else
+        if size.all?{|s| s > 0 }
+          send_data @media_file.thumbnail(size[0],size[1]), :filename => @media_file.name, :type => @media_file.content_type, :disposition => 'inline', :cache => true
+        else
+          render :nothing => true, :status => :unprocessable_entity
+        end
+      end
+    end        
+  end
+  
+  protected
+    def perform_cache
+      return if @skip_caching
+      ActiveRecord::Base.transaction do
+        Skyline::MediaCache.create(:url => request.path, :object_type => "MediaFile", :object_id => @media_file.id)
+        self.class.cache_page(response.body, request.path)
+      end
+    end
+end

data/app/controllers/skyline/publications_controller.rb

@@ -0,0 +1,45 @@
+class Skyline::PublicationsController < Skyline::ApplicationController
+  
+  before_filter :find_article
+  before_filter :find_publication, :only => [:rollback]
+  
+  authorize :rollback, :by => "article_variant_create"
+  
+  def index
+    if request.xhr?
+      render :update do |p|
+        p << "var s = function(){"
+        p << "var sd = new Skyline.Dialog({width: 700, height: 500});"
+        p << "sd.setTitle('#{escape_javascript(t(:dialog_title, :scope => [:publication,:index]))}');"
+        p << "sd.setContent('" + escape_javascript(render(:partial => "index")) + "');"
+        p << "sd.setup(); sd.show();"
+        p << "sd.layout = new Application.Layouts.History(sd.contentEl.getElement('form'));"
+        p << "sd.layout.rollbackUrl = '"+escape_javascript(rollback_skyline_article_publication_path(@article, "000"))+"'"
+        p << "}()"
+      end
+    end
+  end
+  
+  def rollback
+  	return handle_unauthorized_user if @article.locked? && !current_user.allow?(:page_lock)
+  	
+  	new_variant = @publication.rollback({'name' => @publication.name})
+  	notifications[:success] = t(:success, :scope => [:publication, :rollback, :flashes])
+  	redirect_to edit_skyline_article_path(@article, :variant_id => new_variant.id)
+	rescue
+		messages[:error] = t(:error, :scope => [:publication, :rollback, :flashes])
+		redirect_to edit_skyline_article_path(@article)
+	end
+  
+  protected
+  
+  def find_article
+    @article = Skyline::Article.find_by_id(params[:article_id])
+    return redirect_to(skyline_articles_path(:type => params[:article_type])) unless @article
+  end    
+  
+  def find_publication
+    @publication = @article.publications.find_by_id(params[:id])
+    return redirect_to(edit_skyline_articles_path(@article)) unless @publication
+	end
+end

data/app/controllers/skyline/published_publications_controller.rb

@@ -0,0 +1,44 @@
+class Skyline::PublishedPublicationsController < Skyline::ApplicationController
+  before_filter :find_article
+
+  def create
+    return handle_unauthorized_user unless @article.editable_by?(current_user)
+
+    variant = @article.variants.find_by_id(params[:variant_id])
+    if !variant || !variant.editable_by?(current_user)
+      return redirect_to(skyline_page_path(@article)) 
+    end
+    
+    if variant.publish
+      messages[:success] = t(:success, :scope => [:published_publication, @article.class, :create, :flashes])
+    else
+      notifications[:error] = t(:error, :scope => [:published_publication, @article.class, :create, :flashes])
+      flash[:show_errors_for_publication] = true
+    end    
+    redirect_to edit_skyline_article_path(@article, :variant_id => variant.id)
+  end
+  
+  def destroy
+    return handle_unauthorized_user unless @article.editable_by?(current_user)
+
+    if @article.depublishable?
+      @article.depublish
+      messages[:success] = t(:success, :scope => [:published_publication, @article.class, :destroy, :flashes])
+    else
+      if @article.persistent?
+        notifications[:error] = t(:error_persistent, :scope => [:published_publication, @article.class, :destroy, :flashes])
+      else
+        notifications[:error] = t(:error, :scope => [:published_publication, @article.class, :destroy, :flashes])
+      end
+    end
+    
+    redirect_to edit_skyline_article_path(@article, :variant_id => params[:variant_id])
+  end
+  
+  protected
+  def find_article
+    @article = Skyline::Article.find_by_id(params[:article_id])
+    return redirect_to(skyline_articles_path(:type => params[:article_type])) unless @article
+    return handle_unauthorized_user unless @article.editable_by?(current_user)
+  end
+end

data/app/controllers/skyline/redirects_controller.rb

@@ -0,0 +1,5 @@
+class Skyline::RedirectsController < Skyline::ApplicationController
+  def new
+    redirect_to Skyline::Section.find_by_id(params[:redirect_section_id]).sectionable.url(request)
+  end
+end

data/app/controllers/skyline/sections_controller.rb

@@ -0,0 +1,24 @@
+class Skyline::SectionsController < Skyline::ApplicationController
+  before_filter :find_renderable_scope
+    
+  def new
+    return unless request.xhr?
+    render :update do |page|
+      section = Skyline::Section.new
+      section.sectionable = params[:sectionable_type].constantize.new
+      section_guid = Guid.new
+      
+      fields_for params[:object_name] do |variant_form|
+        page.insert_html(:bottom, "contentlist", :partial => "form", :locals => {:variant_form => variant_form, :section => section, :guid => section_guid})
+      end
+      page << "$('contentlist').retrieve('application.sections').addSection('section_#{section_guid}');"
+      page << "var myFx = new Fx.Scroll(\"contentEditPanel\").toBottom();"
+    end
+  end
+  
+  protected
+  def find_renderable_scope
+    @renderable_scope = Skyline::Rendering::Scopes::Interface.unserialize(params[:renderable_scope]) if params[:renderable_scope]
+    raise "Can't load renderable_scope from params[:renderable_scope]: '#{params[:renderable_scope]}'" unless @renderable_scope
+  end
+end

data/app/controllers/skyline/settings_controller.rb

@@ -0,0 +1,30 @@
+class Skyline::SettingsController < Skyline::Skyline2Controller
+  
+  layout "skyline/layouts/settings"
+  
+  self.default_menu_item = :admin
+  
+  authorize :index, :edit, :update, :by => :settings_update
+  
+  def index
+    if @implementation && @implementation.settings
+      redirect_to edit_skyline_setting_path(@implementation.settings.page_names.first)
+    end
+  end
+  
+  def edit
+    @settings = @implementation.settings[params[:id]]
+  end
+  
+  def update
+    @settings = @implementation.settings[params[:id]]
+    @settings.data = params[:settings]
+    if @settings.save
+      notifications[:success] = t(:success, :scope => [:settings, :update, :flashes])
+      redirect_to edit_skyline_setting_path(@settings.page.name)
+    else
+      messages.now[:error] = t(:error, :scope => [:settings, :update, :flashes])
+    end
+  end
+  
+end

data/app/controllers/skyline/site/media_files_data_controller.rb

@@ -0,0 +1,73 @@
+class Skyline::Site::MediaFilesDataController < ApplicationController  
+  after_filter :perform_cache, :only => :show
+  
+  self.page_cache_directory = Skyline::MediaCache.cache_path
+  
+  # show
+  # Renders the requested image with specified size parameters and stores the image in the cache. 
+  # If the image is already in the cache then 304 Not Modified is rendered.
+  #
+  # ==== Parameters
+  # size <String> WidthxHeight
+  
+  def show
+    @skip_caching = false
+
+    filename = "#{params[:name]}.#{params[:format]}"
+    
+    @media_file = Skyline::MediaFile.find(:first, :conditions => {:parent_id => params[:media_dir_id], :name => filename})
+    return self.handle_404 unless @media_file
+    
+    cached_file = File.join(self.page_cache_directory,request.path)    
+    
+    if File.exist?(cached_file)                      
+      response.etag = File.mtime(cached_file)
+          
+      if request.etag_matches?(response.etag)
+        head :not_modified
+      else
+        send_file cached_file, :filename => @media_file.name ,:type => @media_file.content_type, :disposition => 'inline', :stream => false, :cache => true
+      end
+      @skip_caching = true
+    else
+      if params[:size].present?
+        size = params[:size].to_s.split("x").map{|v| v.to_i }
+        size = nil if size[0] == @media_file.width && size[1] >= @media_file.height || size[1] == @media_file.height && size[0] >= @media_file.width
+      else
+        size = nil
+      end
+      
+      if size.nil?
+        response.etag = File.mtime(@media_file.file_path)
+            
+        if request.etag_matches?(response.etag)
+          head :not_modified
+        else
+          send_file @media_file.file_path, :filename => @media_file.name, :type => @media_file.content_type, :disposition => 'inline', :cache => true
+        end
+        @skip_caching = true
+      else
+        if size.all?{|s| s > 0 }
+          send_data @media_file.thumbnail(size[0],size[1]), :filename => @media_file.name, :type => @media_file.content_type, :disposition => 'inline', :cache => true
+        else
+          render :nothing => true, :status => :unprocessable_entity
+        end
+      end
+    end        
+  end
+  
+  protected
+  
+  def handle_404
+    render :nothing => true, :status => :not_found    
+  end
+    
+  def perform_cache
+    return if @skip_caching
+    return unless @media_file
+    ActiveRecord::Base.transaction do
+      Skyline::MediaCache.create(:url => request.path, :object_type => "MediaFile", :object_id => @media_file.id)
+      self.class.cache_page(response.body, request.path)
+    end
+  end
+end

data/app/controllers/skyline/site/pages_controller.rb

@@ -0,0 +1,50 @@
+class Skyline::Site::PagesController < ApplicationController
+  before_filter :find_site, :find_page_version_and_url_parts, :possibly_redirect
+  
+  def show
+    renderer = @site.renderer(:controller => self)
+    
+    if @page_version    
+      
+      # ========
+      # = Page =
+      # ========
+      if renderer.assigns[:body].blank? && @url_parts.empty?
+        renderer.assigns.update(:body => self.response.body)
+      end      
+      
+      render :text => renderer.render(@page_version) if renderer.assigns[:body].present?
+    end    
+
+    # ================================================
+    # = Fallback; render 404 if nothing was rendered =
+    # ================================================
+    self.handle_404 unless performed?
+  end
+  
+  
+  protected
+
+  def handle_404
+    render :text => "Error 404 :: Page with url \"#{params[:url].join("/")}\" doesn't exist.", :status => :not_found    
+  end
+  
+  def find_site
+    @site = Skyline::Site.new
+  end
+  
+  def find_page_version_and_url_parts
+    page, @url_parts = @site.pages.find_by_url(params[:url])
+    @page_version = page.andand.published_publication
+  end
+  
+  def possibly_redirect
+    return if !@page_version || @url_parts.any?
+    if redirect_section = @page_version.sections.detect{|section| section.sectionable.kind_of?(Skyline::Sections::RedirectSection)}
+      if redirect_section.sectionable.delay == 0
+        redirect_to redirect_section.sectionable.url(request)
+      end
+    end
+  end
+end
+

data/app/controllers/skyline/skyline2_controller.rb

@@ -0,0 +1,21 @@
+class Skyline::Skyline2Controller < Skyline::ApplicationController
+  layout "general"
+
+  around_filter VersionStamper.instance  
+
+  before_filter :load_implementation
+
+    
+  protected
+  
+  def load_implementation
+    @implementation = Skyline::Content::Implementation.instance
+  end
+  
+  # Returns the current implementation
+  # --
+  def current_implementation
+    @implementation
+  end
+
+end

data/app/controllers/skyline/users_controller.rb

@@ -0,0 +1,103 @@
+class Skyline::UsersController < Skyline::ApplicationController
+  layout "skyline/layouts/settings"
+  
+  self.default_menu_item = :admin
+  
+  authorize :index, :by => "user_show"
+  authorize :new,:create, :by => "user_create"
+  authorize :edit,:update, :by => "user_update"
+  authorize :destroy, :by => "user_delete"
+  
+  def index
+    
+    @users = Skyline::User.paginate(:per_page => self.per_page,:conditions => {:system => false, :is_destroyed => false}, :include => [:roles], :page => params[:page])
+  end
+  
+  def new
+    @user = Skyline::User.new(params[:user])
+    @roles = @current_user.viewable_roles
+    
+    if request.xhr?
+      render :update do |p|
+        p << dialog(t(:dialog_title, :display_name => @user.display_name, :scope => [:user,:new]), :partial => "new", :width => 700)
+      end
+    end        
+  end
+  
+  def create
+    @user = Skyline::User.new(params[:user])
+    
+    if @user.save
+      notifications[:success] = t(:success, :scope => [:user,:create,:flashes])
+      render :update do |p|
+        p.redirect_to skyline_users_path(:page => page_number_for_user(@user))
+      end
+    else
+      @roles = @current_user.viewable_roles
+      messages.now[:error] = t(:error,:scope => [:user,:create,:flashes])
+      render :update do |p|
+        p << "Skyline.Dialog.current.setContent('#{escape_javascript(render :partial => "new")}'); Skyline.Dialog.current.setup();"
+      end
+    end
+    
+  end
+  
+  def edit
+    @user = Skyline::User.find_by_id(params[:id])
+    @roles = @current_user.viewable_roles
+    
+    if request.xhr?
+      render :update do |p|
+        p << dialog(t(:dialog_title, :display_name => @user.display_name, :scope => [:user,:edit]), :partial => "edit", :width => 700)
+      end
+    end    
+  end  
+  
+  def update
+    @user = Skyline::User.find_by_id(params[:id])
+    @user.attributes = params[:user]
+    @user.force_password = params[:user].andand[:force_password]
+    @user.editing_myself = true if @user == current_user
+    
+    if @user.save
+      notifications[:success] = t(:success, :scope => [:user,:update,:flashes])
+      render :update do |p|
+        p.redirect_to skyline_users_path(:page => page_number_for_user(@user))
+      end
+    else
+      @roles = @current_user.viewable_roles
+      messages.now[:error] = t(:error,:scope => [:user,:update,:flashes])
+      render :update do |p|
+        p << "Skyline.Dialog.current.setContent('#{escape_javascript(render :partial => "edit")}'); Skyline.Dialog.current.setup();"
+      end
+    end
+  end
+  
+  def destroy
+    @user = Skyline::User.find_by_id(params[:id])
+    if @user == current_user
+      notifications[:error] = t(:cant_delete_myself, :scope => [:user,:destroy,:flashes])
+    elsif @user.destroy
+      notifications[:success] = t(:success, :scope => [:user,:destroy,:flashes])
+    else
+      notifications[:error] = t(:error, :scope => [:user,:destroy,:flashes])
+    end 
+
+    render :update do |p|
+      p.redirect_to skyline_users_path(:page => params[:page])
+    end
+  end
+  
+
+  protected
+  
+  def per_page
+    30
+  end
+  
+  def page_number_for_user(user)
+    (Skyline::User.count(:conditions => ["email < :email",{:email => user.email}]).to_i / self.per_page)  + 1
+  end
+  helper_method :page_number_for_user
+
+end