forgeos_blog 1.9.0

data/app/controllers/admin/import_controller.rb

@@ -0,0 +1,14 @@
+load File.join(Gem.loaded_specs['forgeos_cms'].full_gem_path, 'app', 'controllers', 'admin', 'import_controller.rb')
+class Admin::ImportController < Admin::BaseController
+  before_filter :blog_models, :only => :index
+
+  map_fields :create_paper, (Paper.new.attributes.keys + Paper.new.translated_attributes.stringify_keys.keys).sort
+  def create_paper
+    create_model(Paper,nil)
+  end
+
+  private
+  def blog_models
+    @models << 'paper'
+  end
+end

data/app/controllers/admin/papers_controller.rb

@@ -0,0 +1,135 @@
+class Admin::PapersController < Admin::BaseController
+  cache_sweeper :paper_sweeper, :only => [:create, :update, :destroy]
+  before_filter :get_paper, :only => [:edit, :update, :destroy, :show]
+  before_filter :new_paper, :only => [:new, :create]
+  before_filter :get_tags, :only => [:update, :create]
+
+  def url
+    render :text => Forgeos::url_generator(params[:url])
+  end
+
+  # List Categories
+  def index
+    respond_to do |format|
+      format.html
+      format.json do
+        sort
+        render :layout => false
+      end
+    end
+  end
+
+  def new
+  end
+
+  def show
+  end
+
+  # Create a Paper
+  # ==== Params
+  # * paper = Hash of Paper's attributes
+  #
+  # The Paper can be a child of another Paper.
+  def create
+    if @paper.save
+      flash[:notice] = t('paper.create.success').capitalize
+      redirect_to([forgeos_blog, :admin, :papers])
+    else
+      flash[:error] = t('paper.create.failed').capitalize
+      render :action => 'new'
+    end
+  end
+
+  # Edit a Paper
+  # ==== Params
+  # * id = Paper's id to edit
+  # * paper = Hash of Paper's attributes
+  #
+  # The Paper can be a child of another Paper.
+  def edit
+  end
+
+  def update
+    if @paper.update_attributes(params[:paper])
+      flash[:notice] = t('paper.update.success').capitalize
+      redirect_to([forgeos_blog, :admin, :papers])
+    else
+      flash[:error] = t('paper.update.failed').capitalize
+      render :action => 'edit'
+    end
+  end
+
+  # Destroy a Paper
+  # ==== Params
+  # * id = Paper's id
+  # ==== Output
+  #  if destroy succed, return the Categories list
+  def destroy
+    #set page_url for cache sweeper
+    @paper.paper_url = @paper.paper_urls.dup
+    if @paper.destroy
+      flash[:notice] = t('paper.destroy.success').capitalize
+    else
+      flash[:error] = t('paper.destroy.failed').capitalize
+    end
+  end
+
+private
+  def get_paper
+    unless @paper = Paper.find_by_id(params[:id])
+      flash[:error] = t('paper.not_exist').capitalize
+      return redirect_to([forgeos_blog, :admin, :papers])
+    end
+  end
+
+  def new_paper
+    @paper = Paper.new(params[:paper])
+  end
+
+  def get_tags
+    params[:paper][:tag_list]= params[:tag_list].join(',')
+  end
+
+  def sort
+    columns = %w(paper_translations.name paper_translations.name people.lastname papers.state published_at)
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      columns = %w(name name author)
+    end
+
+    per_page = params[:iDisplayLength].to_i
+    offset =  params[:iDisplayStart].to_i
+    page = (offset / per_page) + 1
+    order_column = params[:iSortCol_0].to_i
+    order = "#{columns[order_column]} #{params[:sSortDir_0].upcase}"
+
+    conditions = {}
+    includes = [:translations]
+    options = { :page => page, :per_page => per_page }
+    joins = [:translations]
+
+    if params[:category_id]
+      conditions[:categories_elements] = { :category_id => params[:category_id] }
+      includes << :categories
+      joins = []
+    end
+
+    if params[:ids]
+      conditions[:papers] = { :id => params[:ids].split(',') }
+    end
+
+    options[:conditions] = conditions unless conditions.empty?
+    options[:include] = includes unless includes.empty?
+    options[:order] = order unless order.squeeze.blank?
+    options[:joins] = joins
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      options[:index] = "paper_core.paper_#{ActiveRecord::Base.locale}_core"
+      options[:sql_order] = options.delete(:order)
+      options[:joins] += options.delete(:include)
+      @papers = Paper.search(params[:sSearch],options)
+    else
+      @papers = Paper.paginate(options)
+    end
+  end
+end

data/app/controllers/blog/comments_controller.rb

@@ -0,0 +1,21 @@
+class Blog::CommentsController < ApplicationController
+  include Rakismet::Controller
+  include BlogHelper
+  rakismet_filter :only => :create
+  cache_sweeper :paper_sweeper, :only => :create
+  skip_before_filter :verify_authenticity_token
+  def create
+    @paper = Paper.find(params[:paper_id])
+    @comment = @paper.comments.build(params[:comment])
+    unless @comment.spam?
+      if @comment.valid?
+        @comment.save
+      else
+        @comment.spam!
+      end
+    else
+      flash[:notice] = @comment.akismet_response
+    end
+    redirect_to([:seo, @paper])
+  end
+end

data/app/controllers/blog/papers_controller.rb

@@ -0,0 +1,60 @@
+class Blog::PapersController < ApplicationController
+  before_filter :get_defaults
+  caches_page :show, :if => Proc.new { |c| c.request.format != 'js' }
+
+  def index
+    if params[:tag_name]
+      @tags = ActsAsTaggableOn::Tagging.all(:include => :tag, :conditions => { :tags => { :name => params[:tag_name].humanize }})
+    else
+      @category = PaperCategory.find_by_url(params[:blog_category_id]) || PaperCategory.find_by_id(params[:blog_category_id]) if params[:blog_category_id]
+    end
+
+    paginate_options = {:page => page, :per_page => per_page, :conditions => { :state => 'published'}}
+    case params[:sort_by]
+    when 'popularity'
+      paginate_options[:order] = "sum(#{PaperViewedCounter.table_name}.counter) DESC, papers.id DESC"
+      paginate_options[:include] = :viewed_counters
+      paginate_options[:group] = "papers.id"
+    when 'commented'
+      paginate_options[:order] = "COUNT(#{Comment.table_name}.id) DESC, papers.id DESC"
+      paginate_options[:include] = :comments
+      paginate_options[:group] = "papers.id"
+    else
+      paginate_options[:order] = 'papers.published_at DESC, papers.id DESC'
+    end
+
+    if params[:tag_name]
+      @paper = @tags.collect{ |t| t.papers }.paginate(paginate_options)
+    else
+      @papers = @category ? @category.elements.paginate(paginate_options) : Paper.paginate(paginate_options)
+    end
+
+    respond_to do |format|
+      format.html
+      format.atom
+      format.xml
+      format.rss
+    end
+  end
+
+  def show
+    unless @paper = Paper.find_by_url(params[:id])
+      page_not_found
+    end
+  end
+
+  private
+  def get_defaults
+    @last_comments = Comment.latest_paper_comments(:limit => 5)
+    @last_papers = Paper.latest(:limit => 5)
+    @categories = PaperCategory.all
+  end
+
+  def page
+    params[:page].to_i > 0 ? params[:page] : 1
+  end
+
+  def per_page
+    params[:per_page].to_i > 0 ? params[:per_page] : 5
+  end
+end

data/app/controllers/blog/tags_controller.rb

@@ -0,0 +1,35 @@
+class Blog::TagsController < ApplicationController
+  before_filter :get_defaults
+
+  def index
+    if params[:tag_name]
+
+      paginate_options = {
+        :page => params[:page],
+        :per_page => (params[:per_page] || 5),
+      }
+
+      # OPTIMIZE
+      tags = ActsAsTaggableOn::Tagging.all(
+        :include => :tag,
+        :conditions => {
+          :tags => {
+            :name => params[:tag_name].humanize
+          },
+          :taggable_type => 'Paper'
+        }
+      )
+      papers = tags.map(&:taggable).uniq.select{ |p| p.state == 'published' }
+      unless papers.nil?
+        @papers = papers.paginate(paginate_options)
+      end
+    end
+  end
+
+
+private
+  def get_defaults
+    @last_papers = Paper.latest(:limit => 5)
+    @categories = PaperCategory.all
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+module ApplicationHelper
+  include BlogHelper
+end

data/app/helpers/blog_helper.rb

@@ -0,0 +1,22 @@
+module BlogHelper
+  def tags
+    # FIXME count taggable only if it state is 'published'
+    ActsAsTaggableOn::Tag.count(:name, :joins => 'INNER JOIN taggings ON taggings.tag_id = tags.id' , :conditions => { :taggings => { :taggable_type => 'Paper'}}, :group => 'name', :select => 'name', :limit => 100 )
+  end
+
+  def tag_cloud(tags, classes)
+    counts = tags.map(&:last)
+    min = counts.min
+    max = counts.max
+
+    divisor = ((max - min) / classes.size) + 1
+
+    tags.map do |t|
+      yield t[0], classes[(t[1].to_i - min) / divisor]
+    end
+  end
+
+  def resumer(content, options = {})
+    truncate(content.gsub(/<\/?[^>]*>/, ""), { :length => 500 }.update(options))
+  end
+end

data/app/helpers/routes_helper.rb

@@ -0,0 +1,23 @@
+module RoutesHelper
+  def seo_paper_path(*args)
+    forgeos_blog.blog_paper_path extract_paper_options(args)
+  end
+
+  def seo_paper_url(*args)
+    forgeos_blog.blog_paper_url extract_paper_options(args)
+  end
+
+  def extract_paper_options(args)
+    options = args.extract_options!
+    object = args.first
+    if object.is_a?(Paper)
+      return options.merge(:id => object.url)
+    else
+      args << options
+    end
+  end
+
+  def seo_blog_paper_category_path(category, options={})
+    forgeos_blog.blog_paper_category_path(options.merge(:blog_category_id => category.url))
+  end
+end

data/app/models/comment.rb

@@ -0,0 +1,34 @@
+load File.join(Gem.loaded_specs['forgeos_cms'].full_gem_path,'app','models','comment.rb')
+class Comment < ActiveRecord::Base
+  include Rakismet::Model
+  validates :author_name, :unless => :skip_validates_presence_of_author_name?, :presence => true
+  validates :author_email, :unless => :skip_validates_presence_of_author_email?, :presence => true
+  validates :comment, :unless => :skip_validates_presence_of_comment?, :presence => true
+  rakismet_attrs :content => :comment, :author => :author_name, :comment_type => 'comment'
+
+  def author_name
+    author ? author.fullname : super
+  end
+
+  def author_email
+    author ? author.email : super
+  end
+
+  private
+  def skip_validates_presence_of_author_name?
+    author
+  end
+
+  def skip_validates_presence_of_author_email?
+    author
+  end
+
+  def skip_validates_presence_of_comment?
+    false
+  end
+
+  def self.latest_paper_comments(options = {})
+    all(options.merge({:conditions => { :commentable_type => 'Paper' }, :order => 'created_at DESC'}))
+  end
+
+end

data/app/models/paper.rb

@@ -0,0 +1,57 @@
+class Paper < ActiveRecord::Base
+  acts_as_taggable
+  acts_as_commentable
+  attr_accessor :paper_url
+  accepts_nested_attributes_for :comments, :allow_destroy => true
+
+  belongs_to :picture
+
+  belongs_to :author, :foreign_key => 'person_id', :class_name => 'Person'
+
+  has_one :meta_info, :as => :target
+  accepts_nested_attributes_for :meta_info
+
+  has_and_belongs_to_many :categories, :readonly => true, :join_table => 'categories_elements', :foreign_key => 'element_id', :association_foreign_key => 'category_id', :class_name => 'PaperCategory'
+
+  translates :name, :content, :url, :description
+
+  validates :url, :name, :content, :person_id, :presence => true
+
+  has_many :viewed_counters, :as => :element, :class_name => 'PaperViewedCounter'
+
+  include AASM
+
+  aasm_column :state
+  aasm_initial_state :draft
+  aasm_state :draft
+  aasm_state :published
+
+  aasm_event :publish do
+    transitions :to => :published, :from => :draft
+  end
+
+  aasm_event :throw do
+    transitions :to => :draft, :from => :published
+  end
+
+  def aasm_current_state_with_event_firing=(state)
+    aasm_events_for_current_state.each do |event_name|
+      event = self.class.aasm_events[event_name]
+      aasm_fire_event(event_name,false) if event && event.all_transitions.any?{ |t| t.to == state || t.to == state.to_sym }
+    end
+  end
+
+  alias_method :aasm_current_state_with_event_firing, :aasm_current_state
+
+  scope :popularity, lambda { {
+      :order => "sum(#{PaperViewedCounter.table_name}.counter) DESC, papers.id DESC",
+      :include => :viewed_counters,
+      :group => "papers.id",
+    }
+  }
+  scope :latest, lambda { { :conditions => { :state => 'published' }, :order => 'published_at DESC'} }
+
+  def paper_urls
+    self.translations.collect(&:url)
+  end
+end

data/app/models/paper_category.rb

@@ -0,0 +1,7 @@
+class PaperCategory < Category
+  has_and_belongs_to_many :elements,
+    :join_table => 'categories_elements',
+    :foreign_key => 'category_id',
+    :association_foreign_key => 'element_id',
+    :class_name => 'Paper'
+end

data/app/models/paper_sweeper.rb

@@ -0,0 +1,44 @@
+class PaperSweeper < ActionController::Caching::Sweeper
+  include BlogHelper
+  observe Paper, Comment, PaperCategory
+
+  def after_save(record)
+    expire_cache_for(record)
+  end
+
+  def after_create(record)
+    expire_cache_for(record)
+  end
+
+  def after_destroy(record)
+    expire_cache_for(record)
+  end
+
+  private
+  def expire_cache_for(record)
+    case record
+    when Paper
+      expire_cache_for_paper(record)
+    when PaperCategory
+      expire_all_papers
+    when Comment
+      expire_cache_for_paper(record.commentable) if record.commentable.kind_of?(Paper)
+    else
+      true
+    end
+  end
+
+  def expire_cache_for_paper(paper)
+    urls = (paper.paper_url || paper.paper_urls).compact
+    urls.each do |url|
+      expire_page seo_paper_path(:id => url) if url.present?
+      Rails.logger.info("\033[01;33mURL : #{url.inspect}\033[0m")
+    end
+  end
+
+  def expire_all_papers
+    Paper.all.each do |paper|
+      expire_cache_for_paper(paper)
+    end
+  end
+end

data/app/models/paper_viewed_counter.rb

@@ -0,0 +1,2 @@
+class PaperViewedCounter < StatisticCounter
+end

data/app/views/admin/blocks/_tabs.html.haml

@@ -0,0 +1,8 @@
+%ul.ui-tabs-nav.ui-helper-reset.ui-helper-clearfix.ui-widget-header.ui-corner-all
+  %li.ui-state-default.ui-corner-top= link_to I18n.t('page', :count => 2).capitalize, [forgeos_cms, :admin, :pages]
+  %li.ui-state-default.ui-corner-top.ui-tabs-selected.ui-state-active= link_to I18n.t('block', :count => 2).capitalize, '#content'
+  %li.ui-state-default.ui-corner-top= link_to I18n.t('navigation').capitalize, [forgeos_cms, :admin, :menus]
+  %li.ui-state-default.ui-corner-top= link_to t(:paper, :count => 2).capitalize, [forgeos_blog, :admin, :papers]
+#blocks-header.backgrounds
+  = link_to I18n.t('static_content_block', :count => 1).capitalize, '#', :class => 'selected'
+  = link_to I18n.t('widget', :count => 2).capitalize, [forgeos_cms, :admin, :widgets]

data/app/views/admin/menus/_tabs.html.haml

@@ -0,0 +1,5 @@
+%ul.ui-tabs-nav.ui-helper-reset.ui-helper-clearfix.ui-widget-header.ui-corner-all
+  %li.ui-state-default.ui-corner-top= link_to t('page', :count => 2).capitalize, [forgeos_cms, :admin, :pages]
+  %li.ui-state-default.ui-corner-top= link_to t('block', :count => 2).capitalize, [forgeos_cms, :admin, :static_content_blocks]
+  %li.ui-state-default.ui-corner-top.ui-tabs-selected.ui-state-active= link_to t('navigation').capitalize, '#content'
+  %li.ui-state-default.ui-corner-top= link_to t(:paper, :count => 2).capitalize, [forgeos_blog, :admin, :papers]

data/app/views/admin/pages/_tabs.html.haml

@@ -0,0 +1,5 @@
+%ul.ui-tabs-nav.ui-helper-reset.ui-helper-clearfix.ui-widget-header.ui-corner-all
+  %li.ui-state-default.ui-corner-top.ui-tabs-selected.ui-state-active= link_to t('page', :count => 2).capitalize, '#content'
+  %li.ui-state-default.ui-corner-top= link_to t('block', :count => 2).capitalize, [forgeos_cms, :admin, :static_content_blocks]
+  %li.ui-state-default.ui-corner-top= link_to t('navigation').capitalize, [forgeos_cms, :admin, :menus]
+  %li.ui-state-default.ui-corner-top= link_to t(:paper, :count => 2).capitalize, [forgeos_blog, :admin, :papers]

data/app/views/admin/papers/_comment.html.haml

@@ -0,0 +1,31 @@
+- item = f.object
+- link_id = "item_#{item.id}"
+
+.block-container.widget-modify.comment{:id => link_id}
+  .inner_block-container
+    .block-type
+      = t('paper.posted', :at => item.created_at, :by => content_tag(:span,item.author_name))
+    .block-type.editing
+      %label
+        = "#{I18n.t('comment.author').capitalize} :"
+      %label
+        = "#{I18n.t('comment.author_email').capitalize} :"
+      %label
+        = "#{I18n.t('comment', :count => 1).capitalize} :"
+    .block-name
+      %p=h item.comment
+    .block-name.editing{:id => "edit_#{link_id}"}
+      = f.hidden_field :_destroy, :class => 'delete'
+      = f.text_field :author_name
+      = f.text_field :author_email
+      = f.text_area :comment, :cols => 10, :rows => 2
+      .actions
+        = link_to_function content_tag(:span,I18n.t('save_changes'), :class => 'small-icons save'), "update_comment($('#item_#{item.id}'), $('#edit_item_#{item.id}'))", :class => 'backgrounds action-button'
+
+        = t('or')
+        = link_to I18n.t('cancel').capitalize, '#', :class => 'back-link'
+
+    .widget-actions
+      = link_to '','#', :class => 'small-icons edit-link', :id => "edit-comment-#{item.id}"
+      = link_to_function '', "remove_comment($(this));", :class => 'small-icons destroy-link', :id => "delete-comment-#{item.id}"
+    .clear

data/app/views/admin/papers/_comments.html.haml

@@ -0,0 +1,3 @@
+.grid_12
+  = f.fields_for :comments do |comment_form|
+    = render :partial => 'comment', :locals => { :f => comment_form }

data/app/views/admin/papers/_form.html.haml

@@ -0,0 +1,20 @@
+= render :partial => 'admin/menus/lang_switcher'
+= render :partial => 'tabs'
+= form_for [forgeos_blog, :admin, paper], :html => { :id => 'wrap' } do |f|
+  #blocks-header.ui-tabs.ui-widget.ui-widget-content.ui-corner-all
+    %ul.ui-tabs-nav.ui-helper-reset.ui-helper-clearfix.ui-widget-header.ui-corner-all
+      %li.ui-state-default.ui-corner-top.ui-tabs-selected.ui-state-active= link_to t(:general), '#general', :class => 'selected'
+      %li.ui-state-default.ui-corner-top= link_to t(:comment,:count => 2), '#comments'
+      %li.ui-state-default.ui-corner-top= link_to t(:seo), '#seo'
+    .backgrounds.big-header
+      = f.text_field :name, :class => 'field_name big_orange_input'
+      .interact-links
+        = Forgeos_save_buttons [forgeos_blog, :admin, :papers]
+    #general
+      = render :partial => 'general', :locals => {:f => f, :paper => paper }
+      .clear
+    #comments
+      = render :partial => 'comments', :locals => { :f => f, :paper => paper }
+    #seo
+      = render :partial => 'seo', :locals => { :f => f, :paper => paper }
+    .clear

data/app/views/admin/papers/_general.html.haml

@@ -0,0 +1,42 @@
+.grid_12.alpha
+  .inner-content
+    = f.label :description
+    %div= f.text_area :description, :cols => 90, :rows => 5
+    .clear
+    = f.label :content
+    %div= f.text_area :content, :class => 'mceEditor'
+    .clear
+    = display_visual(f.object_name, f.object.picture)
+
+#right-sidebar.grid_4.omega
+  .step.status.open
+    - states_for_select = Paper.aasm_states.collect{ |state| [t(state.name, :scope => [:paper,:states]),state.name.to_s] }
+    %div= f.select :aasm_current_state_with_event_firing, options_for_select(states_for_select, paper.state)
+    = f.label :person_id, t('paper.author')
+    %div= f.collection_select :person_id,Person.all, :id, :fullname, { :prompt => t(:please_select)}
+    = f.label :published_at, t('paper.published_at')
+    = f.text_field :published_at, :size => 10, :class => 'date-picker'
+    .clear
+  .step.open
+    %a.small-icons.step-title{ :href => "#" }
+      = "#{I18n.t('folder.associated_to').capitalize} :"
+    #association-paper-tree.inner-step.init-tree
+      %ul
+        = render :partial => 'admin/categories/associated_elements', :locals => { :association_id => 'category_ids', :element => paper, :category_ids => paper.category_ids, :categories => PaperCategory.find_all_by_parent_id(nil) }
+    .clear
+  #paper_tags.step.open
+    %a.small-icons.step-title{ :href => "#" }
+      Tags
+    .inner-step.tags
+      .wrap_tags
+        -#TODO write good css for tags to remove inline styles 
+        = hidden_field_tag 'tag_list[]', ''
+        %input#tag.backgrounds{ :name => "tag", :type => "text", :title => I18n.t('tag_enter').capitalize, :class => 'defaultValue' }
+        - f.object.tag_list.each do |tag|
+          %span{ :style => 'margin: 5px'}
+            = tag
+            = hidden_field_tag 'tag_list[]', tag
+            = link_to ' ', '#', :class => 'big-icons gray-destroy', :style => 'position: relative !important;float: right;top:0;right: 0;padding: 0; margin: 0 0 0 5px '
+      .clear
+
+= render :partial => 'admin/visual/visual_popup.html.haml', :locals => {:form => f}

data/app/views/admin/papers/_seo.html.haml

@@ -0,0 +1,31 @@
+.grid_12
+  .fieldset.open
+    %h3.permalink
+      = I18n.t('permalink').capitalize
+      \:
+    .option-panel-content
+      = seo_paper_url(f.object.class.new(:url=>'_'))
+      = f.text_field :url
+  .fieldset.open
+    %h3= t(:meta_info, :count => 1)
+    .option-panel-content.meta
+      - f.object.build_meta_info unless f.object.meta_info
+      - f.fields_for :meta_info do |meta_info|
+        %p
+          %span
+            = t(:title).capitalize
+            \:
+          .clear
+          = meta_info.text_field :title, :class => 'text', :size => 90
+        %p
+          %span
+            = t(:description).capitalize
+            \:
+          .clear
+          = meta_info.text_area :description, :class => 'text', :cols => 90, :rows => 5
+        %p
+          %span
+            = t(:keyword, :count => 2).capitalize
+            \:
+          .clear
+          = meta_info.text_area :keywords, :class => 'text', :cols => 90, :rows => 5

data/app/views/admin/papers/_tabs.html.haml

@@ -0,0 +1,5 @@
+%ul.ui-tabs-nav.ui-helper-reset.ui-helper-clearfix.ui-widget-header.ui-corner-all
+  %li.ui-state-default.ui-corner-top= link_to t('page', :count => 2).capitalize, [forgeos_cms, :admin, :pages]
+  %li.ui-state-default.ui-corner-top= link_to t('block', :count => 2).capitalize, [forgeos_cms, :admin, :static_content_blocks]
+  %li.ui-state-default.ui-corner-top= link_to t('navigation').capitalize, [forgeos_cms, :admin, :menus]
+  %li.ui-state-default.ui-corner-top.ui-tabs-selected.ui-state-active= link_to t(:paper, :count => 2).capitalize, '#content'

data/app/views/admin/papers/destroy.js.erb

@@ -0,0 +1 @@
+removedataTablesRow('#destroy_paper_<%= @paper.id-%>');

data/app/views/admin/papers/edit.html.haml

@@ -0,0 +1 @@
+= render :partial => 'form', :locals => { :paper => @paper }

data/app/views/admin/papers/index.html.haml

@@ -0,0 +1,12 @@
+= render :partial => 'tabs'
+= render :partial => 'admin/sidebars/left_sidebar', :locals => {:icon_class => 'papers', :sidebar_title => 'paper.all', :tree_id =>'paper-tree' }
+#content.grid_12.alpha.omega
+  .backgrounds.header
+    = link_to content_tag(:span,t('paper.create.action').capitalize, :class=>'big-icons create-paper'), [forgeos_blog, :new, :admin, :paper], :class=>'backgrounds action-button'
+    #search.right
+      = link_to content_tag(:span, t('search').capitalize, :class => 'small-icons search-span'), '#', :class => 'small-icons left search-link'
+    .backgrounds.search-form
+  .content-background
+  %table#table.datatable.draggable_rows
+
+= dataTables_tag :url => forgeos_blog.admin_papers_path(:format => :json), :columns => ["{'bSearchable':false,'bSortable':false}","{'sTitle':'#{t :name}'}","{'sTitle':'#{t 'paper.author'}'}","{'sTitle':'#{t :status, :count => 1}'}","{'sTitle':'#{t :published_at, :scope => :paper}'}","{'sClass':'actions-td','bSearchable':false,'bSortable':false}"]