SoundSoftware Code Site

gem 'bibtex-ruby'

gem 'nokogiri'

gem 'citeproc'

gem 'citeproc-ruby'

gem 'csl-styles'

= bibliography

Description goes here

class AuthorsController < ApplicationController

  helper :publications

  include PublicationsHelper

  def index

    @authors = Author.find(:all)

  end

  def show

    @author = Author.find(params[:id])

  end

end

class AuthorshipsController < ApplicationController

    def sort

        @authorships = Authorship.find(params['authorship'])

        @authorships.each do |authorship|

            # note: auth_order is usually called position (default column name in the acts_as_list plugin )

            authorship.auth_order = params['authorship'].index(authorship.id.to_s) + 1

            authorship.save

        end

        render :nothing => true, :status => 200

    end

end

class BibtexEntriesController < ApplicationController

end

# -*- coding: utf-8 -*-

# vendor/plugins/redmine_bibliography/app/controllers/publications_controller.rb

class PublicationsController < ApplicationController

  unloadable

  model_object Publication

  before_filter :find_model_object, :only => [ :show, :add_project ]

  before_filter :find_project_by_project_id, :authorize, :only => [ :edit, :new, :update, :create ]

  def new

    find_project_by_project_id

    @publication = Publication.new

    # we'll always want a new publication to have its bibtex entry

    @publication.build_bibtex_entry

  end

  def create

    @project = Project.find(params[:project_id])

    @publication = Publication.new(params[:publication])

    @publication.projects << @project unless @project.nil?

    if @publication.save

      @publication.notify_authors_publication_added(@project)

      flash[:notice] = "Successfully created publication."

      redirect_to :action => :show, :id => @publication, :project_id => @project

    else

      render :action => 'new', :project_id => @project

    end

  end

  def index

    if !params[:project_id].nil?

      find_project_by_project_id

      @project = Project.find(params[:project_id])

      @publications = Publication.find :all, :joins => :projects, :conditions => ["project_id = ?", @project.id]

    else

      @publications = Publication.find :all

    end

  end

  def new_from_bibfile

    @publication.current_step = session[:publication_step]

    # contents of the paste text area

    bibtex_entry = params[:bibtex_entry]

    # method for creating "pasted" bibtex entries

    if bibtex_entry

      parse_bibtex_list bibtex_entry

    end

  end

  def show_bibtex_fields

    @fields = []

    unless params[:value].empty?

      @fields = BibtexEntryType.fields(params[:value])

    end

    respond_to do |format|

      format.js {

        render :show_bibtex_fields

      }

    end

  end

  def add_author

    if (request.xhr?)

      render :text => User.find(params[:user_id]).name

    else

      # No?  Then render an action.

      #render :action => 'view_attribute', :attr => @name

      logger.error { "Error while adding Author to publication." }

    end

  end

  def edit

    find_project_by_project_id unless params[:project_id].nil?

    @publication = Publication.find(params[:id])

    @selected_bibtex_entry_type_id = @publication.bibtex_entry.entry_type

    @bibtype_fields = BibtexEntryType.fields(@selected_bibtex_entry_type_id)

  end

  def update

    @publication = Publication.find(params[:id])

    if @publication.update_attributes(params[:publication])

      flash[:notice] = "Successfully updated Publication."

      # expires the previosly cached entries

      Rails.cache.delete "publication-#{@publication.id}-ieee"

      Rails.cache.delete "publication-#{@publication.id}-bibtex"

      if !params[:project_id].nil?

        redirect_to :action => :show, :id => @publication, :project_id => params[:project_id]

      else

        redirect_to :action => :show, :id => @publication

      end

    else

      render :action => 'edit'

    end

  end

  def show

    find_project_by_project_id unless params[:project_id].nil?

    if @publication.nil?

      @publications = Publication.all

      render "index", :alert => 'The publication was not found!'

    else

      @authors = @publication.authors

      @bibtext_entry = @publication.bibtex_entry

    end

  end

  # parse string with bibtex authors

  def parse_authors(authors_entry)

    # in bibtex the authors are always seperated by "and"

    return authors_entry.split(" and ")

  end

  # parses a list of bibtex

  def parse_bibtex_list(bibtex_list)

    bibliography = BibTeX.parse bibtex_list

    no_entries = bibliography.data.length

    # parses the bibtex entries

    bibliography.data.map do |d|

      if d.class == BibTeX::Entry

        create_bibtex_entry d

      end

    end

  end

  def create_bibtex_entry(d)

    @publication = Publication.new

    @bentry = BibtexEntry.new

    authors = []

    institution = ""

    email = ""

    d.fields.keys.map do |field|

      case field.to_s

      when "author"

        authors = parse_authors d[field]

      when "title"

        @publication.title = d[field]

      when "institution"

        institution = d[field]

      when "email"

        email = d[field]

      else

        @bentry[field] = d[field]

      end

    end

    @publication.bibtex_entry = @bentry

    @publication.save

    # need to save all authors

    #   and establish the author-publication association

    #   via the authorships table

    authors.each_with_index.map do |authorname, idx|

      author = Author.new(:name => authorname)

      if author.save!

        # todo: catch the errors...

        puts "SAVED"

      else

        puts "NOT SAVED"

      end

      author.authorships.create!(

      :publication => @publication,

      :institution => institution,

      :email => email,

      :order => idx)

    end

  end

  def autocomplete_for_project

    @publication = Publication.find(params[:id])

    @projects = Project.active.name_or_homepage_like(params[:q]).find(:all, :limit => 100) - @publication.projects

    logger.debug "Query for \"#{params[:q]}\" returned \"#{@projects.size}\" results"

    render :layout => false

  end

  def autocomplete_for_author

    @results = []

    object_id = params[:object_id]

    @object_name = "publications[authorships_attributes][#{object_id}][search_results]"

    # todo: make sure query works with both pgres and mysql ~lf.20131010

    authors_list = Author.joins(:authorships).where("LOWER(authorships.name_on_paper) LIKE LOWER(?)", "%#{params[:term]}%").uniq

    # name_like scope, defined in lib/user_author patch

    users_list = User.active.name_like(params[:term]).find(:all, :limit => 100)

    logger.debug "Query for \"#{params[:term]}\" returned \"#{authors_list.size}\" authors and \"#{users_list.size}\" users"

    # will check if any of the members of the users list

    #  doesn't belong to the authors list

    @results = authors_list

    users_list.each do |user|

      @results << user unless authors_list.include?(user.author)

    end

    logger.debug { "Autocomplete_for_author results --> #{@results}" }

    render :layout => false

  end

  def sort_author_order

    params[:authorships].each_with_index do |id, index|

      Authorship.update_all(['auth_order=?', index+1], ['id=?', id])

    end

    render :nothing => true

  end

  def add_project

    @projects = Project.find(params[:publication][:project_ids])

    @publication.projects << @projects

    @project = Project.find(params[:project_id])

    # TODO luisf should also respond to HTML???

    respond_to do |format|

      format.html { redirect_to :back }

      format.js {

        render(:update) {|page|

          page[:add_project_form].reset

          page.replace_html :list_projects, :partial => 'list_projects'

        }

      }

    end

  end

  def remove_project

    @project = Project.find(params[:project_id])

    proj = Project.find(params[:remove_project_id])

    if @publication.projects.length > 1

      if @publication.projects.exists? proj

        @publication.projects.delete proj if request.post?

      end

    else

      logger.error { "Cannot remove project from publication list" }

    end

    logger.error { "CURRENT project name#{proj.name} and wanna delete #{@project.name}" }

    render(:update) {|page|

      page.replace_html "list_projects", :partial => 'list_projects', :id  => @publication

    }

  end

  def destroy

    find_project_by_project_id unless params[:project_id].nil?

    @publication = Publication.find(params[:id])

    @publication.destroy

    flash[:notice] = "Successfully deleted Publication."

    redirect_to :controller => :publications, :action => 'index', :project_id => @project

  end

  private

end

module AuthorsHelper

  unloadable

  def render_author_publications(author)

    s = ""

    pubs = []

    author.publications.each do |pub|

     pubs << link_to(pub.title, pub)

    end

    if pubs.size < 3

      s << '<nobr>' << pubs.join(', ') << '</nobr>'

    else

      s << pubs.join(', ')

    end

    s

  end

  # Generates a link to an author

  #   todo: test options

  def link_to_author(author, options={}, html_options = nil)

    url = {:controller => 'authors', :action => 'show', :id => author}.merge(options)

    link_to(h(author.name), url, html_options)

  end

end

# -*- coding: utf-8 -*-

module AuthorshipsHelper

  # Generates a link to either author or user, depending on which is

  # available

  def link_to_authorship(authorship)

    s = ''

    if authorship.author.nil?

      # legacy reasons…

      s << h(authorship.name_on_paper)

    else

      if authorship.author.user.nil?

        s << link_to(authorship.name_on_paper, :controller => 'authors', :action => 'show', :id => authorship.author)

      else

        s << link_to(authorship.name_on_paper, :controller => 'users', :action => 'show', :id => authorship.author.user)

      end

    end

    s.html_safe

  end

end

module BibtexEntriesHelper

end

# -*- coding: utf-8 -*-

require 'bibtex'

module PublicationsHelper

  include AuthorshipsHelper

  def link_to_publication(publication, options={}, html_options = nil)

    url = {:controller => 'publications', :action => 'show', :id => publication}.merge(options)

    link_to(h(publication.title), url, html_options)

  end

  def projects_check_box_tags(name, projects)

    s = ''

    projects.sort.each do |project|

      if User.current.allowed_to?(:edit_publication, project)

        s << "<label>#{ check_box_tag name, project.id, false } #{link_to_project project}</label>\n"

        s << '<br />'

      end

    end

    s.html_safe

  end

  def link_to_remove_fields(name, f)

    f.hidden_field(:_destroy) + link_to_function(name, "remove_fields(this)", :class => 'icon icon-del')

  end

  def link_to_add_author_fields(name, f, association, action)

    new_object = f.object.class.reflect_on_association(association).klass.new

    fields = f.fields_for(association, new_object, :child_index => "new_#{association}") do |builder|

      # renders _authorship_fields.html.erb

      render(association.to_s.singularize + "_fields", :f => builder)

    end

    link_to_function(name, "add_author_fields(this, '#{association}', '#{escape_javascript(fields)}', '#{action}')", { :class => 'icon icon-add', :id => "add_another_author" })

  end

  def sanitized_object_name(object_name)

    object_name.gsub(/\]\[|[^-a-zA-Z0-9:.]/,"_").sub(/_$/,"")

  end

  def sanitized_method_name(method_name)

    method_name.sub(/\?$/, "")

  end

  def form_tag_name(object_name, method_name)

      str = "#{object_name.to_s}[#{sanitized_method_name(method_name.to_s)}]"

      str.to_sym

  end

  def form_tag_id(object_name, method_name)

    str = "#{sanitized_object_name(object_name.to_s)}_#{sanitized_method_name(method_name.to_s)}"

    str.to_sym

  end

  def form_object_id(object_name)

    str = object_name.split("\[").last().gsub("\]","")

    str.to_sym

  end

  def render_authorships_list(publication)

    s = '<p>'

    publication.authorships.each do |authorship|

      s << link_to_authorship(authorship)

      s << "<br /><em>#{authorship.institution}</em></p>"

    end

    s.html_safe

  end

  def render_projects_list(publication, show_delete_icon)

    s= ""

    publication.projects.visible.each do |proj|

      s << link_to_project(proj, {}, :class => 'publication_project')

      if show_delete_icon

        if User.current.allowed_to?(:edit_publication, @project)

          if @project == proj

            # todo: move this message to yml file

            confirm_msg = 'Are you sure you want to remove the current project from this publication\'s projects list?'

          else

            confirm_msg = false

          end

          s << link_to(l(:button_delete), { :url => { :controller => 'publications', :action => 'remove_project', :id => publication, :remove_project_id => proj,  :project_id => @project }, :method => :post, :confirm => confirm_msg }, :class => 'icon icon-del', :remote => :true)

        end

      end

      s << "<br />"

    end

    s.html_safe

  end

  def print_ieee_format(publication)

    Rails.cache.fetch("publication-#{publication.id}-ieee") do

      entry = publication.print_entry(:ieee)

      if entry

        entry.html_safe

      end

    end

  end

  def print_bibtex_format(publication)

    Rails.cache.fetch("publication-#{publication.id}-bibtex") do

      publication.print_entry(:bibtex)

    end

  end

  def show_bibtex_fields(bibtex_entry)

    s = ""

    bibtex_entry.attributes.keys.sort.each do |key|

      value = bibtex_entry.attributes[key].to_s

      next if key == 'id' or key == 'publication_id' or value == ""

      s << "<h4>" + l("field_#{key}") + "</h4>"

      s << "<p>"

      if key == "entry_type"

        s << bibtex_entry.entry_type_label

      else

        s << value

      end

      s << "</p>"

    end

    s

  end

end

def render_authorship_link(link_class, link_id)

  # Renders a link for an author used when adding authors for a publication

  # link_class can be either User or Author

  # link_id will be the id of the Author/User we wish to link

  s= ""

  if link_class == "Author"

    url = {:controller => 'authors', :action => 'show', :id => link_id}

    s << link_to(h(Author.find(link_id).name), url)

  else

    url = {:controller => 'users', :action => 'show', :id => link_id}

    s << link_to(h(User.find(link_id).name), url)

  end

  s.html_safe

end

class Author < ActiveRecord::Base

  unloadable

  has_many :authorships, :dependent => :destroy

  has_many :publications, :through => :authorships

  belongs_to :user

  def <=>(author)

    name.downcase <=> author.name.downcase

  end

  # todo: review usage of scope --lf.20130108

  scope :like, lambda {|q|

    s = "%#{q.to_s.strip.downcase}%"

    {:conditions => ["LOWER(name) LIKE :s", {:s => s}],

     :order => 'name'

    }

  }

  def institution

    if self.authorships.first.nil?

      ""

    else

      self.authorships.first.institution

    end

  end

  def mail

    if self.authorships.first.nil?

      ""

    else

      self.authorships.first.mail

    end

  end

  # todo: need to fix the name getter

  def name

    if self.authorships.first.nil?

      ""

    else

      self.authorships.first.name

    end

  end

end

class Authorship < ActiveRecord::Base

  unloadable

  belongs_to :author

  belongs_to :publication

  accepts_nested_attributes_for :author

  accepts_nested_attributes_for :publication

  validates_presence_of :name_on_paper

  attr_writer :search_author_id , :search_author_class

  attr_writer :search_author_tie

  ### attr_accessor :search_results, :identify_author

  ## attr_writer :search_author_class

  before_save :set_author

  before_update :delete_publication_cache

  # tod: review scope of ordering

  acts_as_list :column => 'auth_order'

  # todo: review usage of scope --lf.20130108

  scope :like_unique, lambda {|q|

    s = "%#{q.to_s.strip.downcase}%"

    {:conditions => ["LOWER(name_on_paper) LIKE :s OR LOWER(email) LIKE :s", {:s => s}],

     :order => 'name_on_paper',

     :group => "name_on_paper, institution, email"

    }

  }

  # todo: review usage of scope --lf.20130108

  scope :like, lambda {|q|

    s = "%#{q.to_s.strip.downcase}%"

    {:conditions => ["LOWER(name_on_paper) LIKE :s OR LOWER(email) LIKE :s", {:s => s}],

     :order => 'name_on_paper'

    }

  }

  def search_author_class

    # Authorship must always have an Author

    # unless it hasn't been saved yet

    # using default setter (attr_writer)

    if self.author.nil?

      aclass = ""

    else

      aclass = "Author"

    end

    @search_author_class || aclass

  end

  def search_author_id

    if self.author.nil?

      authid = ""

    else

      authid = author_id

    end

    @search_author_id || authid

  end

  def search_author_tie

    if self.author.nil?

      auth_tie = false

    else

      auth_tie = true

    end

    @search_author_tie || auth_tie

  end

  def name

    return self.name_on_paper

  end

  def <=>(authorship)

    name.downcase <=> authorship.name.downcase

  end

  def mail

    return self.email

  end

  protected

  def delete_publication_cache

    publication = Publication.find(self.publication_id)

    Rails.cache.delete "publication-#{publication.id}-ieee"

    Rails.cache.delete "publication-#{publication.id}-bibtex"

  end

  private

  def set_author

    # do we want to associate the authorship

    #  with an existing author/user?

    if @search_author_tie

      # if an author, simply associates with it

      # if an user, checks if it has already an author associated with it

      #   if so, associates with that author

      #   otherwise, creates a new author

      case @search_author_class

      when ""

        author = Author.new

        author.save

      when "User"

        user = User.find(@search_author_id)

        if user.author.nil?

          # User w/o author:

          # create new author and update user

          author = Author.new

          author.save

          user.author = author

          user.save

        else

          author = user.author

        end

      when "Author"

        author = Author.find(@search_author_id)

      end

    # if we don't want to associate with an existing author/user

    else

      # todo: should we delete any previously existing relationship?

      author = Author.new

      author.save

    end

    self.author = author

  end

end

class BibtexEntry < ActiveRecord::Base

  unloadable

  belongs_to :publication

  validates_presence_of :entry_type

  def entry_type_name

    entry_type = self.entry_type

    BibtexEntryType.find(entry_type).name

  end

  def entry_type_label

    entry_type = self.entry_type

    BibtexEntryType.find(entry_type).label

  end

end

class BibtexEntryType < ActiveRecord::Base

  unloadable

  @@fields = Hash['article', ['journal', 'year', 'volume', 'number', 'pages', 'month', 'note' ],

                  'book' , [ 'editor', 'publisher', 'volume', 'series', 'address', 'edition', 'month', 'year', 'note' ],

                  'booklet' , [ 'howpublished', 'address', 'year', 'month', 'note', 'key' ],

                  'conference', [ 'booktitle', 'year', 'editor', 'pages', 'organization', 'publisher', 'address', 'month', 'note' ],

                  'inbook', [ 'editor', 'publisher', 'chapter', 'pages', 'volume', 'series', 'address', 'edition', 'year', 'note' ],

                  'incollection', [ 'editor', 'publisher', 'chapter', 'pages', 'volume', 'series', 'address', 'edition', 'year', 'note' ],

                  'inproceedings', [ 'booktitle', 'year', 'editor', 'pages', 'organization', 'publisher', 'address', 'month', 'note' ],

                  'manual', [ 'organization', 'address', 'edition', 'month', 'year', 'note' ],

                  'masterthesis', [ 'school', 'year', 'address', 'month', 'note' ],

                  'misc', [ 'howpublished', 'month', 'year', 'note' ],

                  'phdthesis', [ 'school', 'year', 'address', 'month', 'note' ],

                  'proceedings', [ 'booktitle', 'year', 'editor', 'pages', 'organization', 'publisher', 'address', 'month', 'note' ],

                  'techreport', [ 'year', 'type', 'number', 'address', 'month', 'note' ],

                  'unpublished', [ 'note', 'month', 'year' ]]

  def redundant?

    name == 'conference'  # conference is a duplicate of inproceedings

  end

  def label

    l("field_bibtex_#{name}")

  end

  def self.fields (type)

    @@fields[ self.find(type).name ]

  end

end

# vendor/plugins/redmine_bibliography/app/models/publication.rb

class Publication < ActiveRecord::Base

  unloadable

  has_many :authorships, :dependent => :destroy, :order => "auth_order ASC"

  has_many :authors, :through => :authorships, :uniq => true

  has_one :bibtex_entry, :dependent => :destroy

  validates_presence_of :title

  validates_length_of :authorships, :minimum => 1, :message => l("error_no_authors")

  validates_associated :bibtex_entry, :authorships

  accepts_nested_attributes_for :authorships

  accepts_nested_attributes_for :authors, :allow_destroy => true

  accepts_nested_attributes_for :bibtex_entry, :allow_destroy => true

  has_and_belongs_to_many :projects, :uniq => true

  before_save :set_initial_author_order

  scope :visible, lambda {|*args| { :include => :projects,

                                    :conditions => Project.allowed_to_condition(args.shift || User.current, :view_publication, *args) } }

  acts_as_activity_provider :type => 'publication',

                            :timestamp => "#{Publication.table_name}.created_at",

                            :find_options => {

                              :include => :projects,

                              :conditions => "#{Project.table_name}.id = projects_publications.project_id"

                            }

  acts_as_event :title => Proc.new {|o| o.title },

                :datetime => :created_at,

                :type => 'publications',

                :author => nil,

                #todo - need too move the cache from the helper to the model

                :description => Proc.new {|o| o.print_entry(:ieee)},

                :url => Proc.new {|o| {:controller => 'publications', :action => 'show', :id => o.id }}

  # Ensure error message uses proper text instead of

  # bibtex_entry.entry_type (#268).  There has to be a better way to

  # do this!

  def self.human_attribute_name(k, *args)

    if k == 'bibtex_entry.entry_type'

      l(:field_entry_type)

    else

      super

    end

  end

  def notify_authors_publication_added(project)

    self.authors.each do |author|

      Rails.logger.debug { "Sending mail to \"#{self.title}\" publication authors." }

      Mailer.publication_added(author.user, self, project).deliver unless author.user.nil?

    end

  end

  def notify_authors_publication_updated(project)

    self.authors.each do |author|

      Rails.logger.debug { "Sending mail to \"#{self.title}\" publication authors." }

      Mailer.publication_updated(author.user, self, project).deliver unless author.user.nil?

    end

  end

  def set_initial_author_order

    authorships = self.authorships

    logger.debug { "Publication \"#{self.title}\" has #{authorships.size} authors." }

    authorships.each_with_index do |authorship, index|

      if authorship.auth_order.nil?

         authorship.auth_order = index

      end

    end

  end

  def print_bibtex_author_names

    # this authors are correctly sorted because the authorships model

    # already outputs the author names ASC by auth_order

    self.authorships.map{|a| a.name_on_paper}.join(' and ')

  end

  def print_entry(style)

    bib = BibTeX::Entry.new

    bib.author = self.print_bibtex_author_names

    bib.title = self.title

    self.bibtex_entry.attributes.keys.sort.each do |key|

      value = self.bibtex_entry.attributes[key].to_s

      next if key == 'id' or key == 'publication_id' or value == ""

      if key == "entry_type"

        bib.type = BibtexEntryType.find(self.bibtex_entry.entry_type).name

      else

        bib[key.to_sym] = value

      end

    end

    if style == :ieee

      citeproc = bib.to_citeproc

      cite_id = citeproc["id"]

      #!!! These warns should go once I've figured out why it's not rendering!

      logger.warn { "rendering citation #{citeproc} with id #{ cite_id }" }

      cp = CiteProc::Processor.new style: 'ieee', format: 'html'

      cp.import citeproc

      cp.render :bibliography, id: cite_id

      logger.warn { "rendered" }

      result

#      CiteProc.process(bib.to_citeproc, :style => :ieee, :format => :html)

    else

      bibtex = bib.to_s :include => :meta_content

      bibtex.strip!

    end

  end

end

<% events = @events_by_day %>

<% max = 5 %>

<% if (events.nil?)

     activity = Redmine::Activity::Fetcher.new(User.current, :project => @project)

     if @project

        # Don't show news (duplicated with News box) or wiki edits (too

	# tedious) in project front page

        activity.scope = [ "changesets", "files", "issues", "documents" ]

     end

     events = activity.events(Date.today - 28, Date.today + 1)

     if defined? user

        events = events.select { |e|

          if e.class != Publication

            user.member_of? e.project

          else

            e.projects.map {|p| user.member_of? p }.any?

          end

        }

     end

     events = events.first(max)

   end

%>

<div id="activity">

<% if @project.nil? %>

   <%= content_tag('h3', l(:label_activity_my_recent)) %>

   <div class="activity box">

<% end %>

<% if events.empty? %>

   <% if @project.nil? %>

     <div class="tip"><%= l(:label_activity_my_recent_none) %></div>

   <% end %>

<% else %>

   <% if !@project.nil? %>

     <div class="activity box">

     <%= content_tag('h3', l(:label_activity_recent)) %>

   <% end %>

   <dl>

   <% events.sort {|x,y| y.event_datetime <=> x.event_datetime }.each do |e| -%>

    <%- if e.class != Publication -%>

      <dt class="<%= User.current.logged? && e.respond_to?(:event_author) && User.current == e.event_author ? 'me' : nil %>">

     	<%= avatar(e.event_author, :size => "24") if e.respond_to?(:event_author) %>

        <span class="time"><%= format_time(e.event_datetime) %></span>

        <%= content_tag('span', link_to_project(e.project), :class => 'project') if @project.nil? || @project != e.project %>

        <% if e.respond_to?(:event_author) %>

          <span class="author"><%= e.event_author %></span>

        <% end %>

      </dt>

      <dd><%= link_to format_activity_title(e.event_title), e.event_url %>

        <span class="description"><%= format_activity_description(e.event_description) %></span>

      </dd>

     <% else -%>

      <dt class="<%= User.current.logged? && e.respond_to?(:event_author) && User.current == e.event_author ? 'me' : nil %>">

         <span class="time"><%= format_time(e.event_datetime) %></span>

          <%= link_to format_activity_title(e.event_title), e.event_url %>

      was added to the following

      <% if e.projects.count > 1 %>

        projects:

      <%- else -%>

        project:

      <%- end -%>

      <%= content_tag('span', e.projects.join(', ')) -%>         <% if e.respond_to?(:event_author) %>

             <span class="author"><%= e.event_author %></span>

         <% end %>

        </dt>

           <dd><%= link_to format_activity_title(e.event_title), e.event_url %>

           <span class="description"><%= format_activity_description(e.event_description) %></span>

           </dd>

     <% end -%>

   <% end -%>

   </dl>

   </div>

<% end %>

<% if events.empty? and @project.nil? %></div><% end %>

</div>

<h2><%=

  if @author.nil?

    if @institution_name.blank?

      l(:label_activity)

    else

      l(:label_institution_activity, h(@institution_name))

    end

  else

    l(:label_user_activity, link_to_user(@author)).html_safe

  end

  %></h2>

<p class="subtitle"><%= l(:label_date_from_to, :start => format_date(@date_to - @days), :end => format_date(@date_to-1)) %></p>

<div id="activity">

<% @events_by_day.keys.sort.reverse.each do |day| %>

<h3><%= format_activity_day(day) %></h3>

<dl>

<% sort_activity_events(@events_by_day[day]).each do |e, in_group| -%>

  <%- if e.class != Publication -%>

    <dt class="<%= e.event_type %> <%= "grouped" if in_group %> <%= User.current.logged? && e.respond_to?(:event_author) && User.current == e.event_author ? 'me' : nil %>">

      <%= avatar(e.event_author, :size => "24") if e.respond_to?(:event_author) %>

      <span class="time"><%= format_time(e.event_datetime, false) %></span>

      <%= content_tag('span', h(e.project), :class => 'project') if @project.nil? || @project != e.project %>

      <%= link_to format_activity_title(e.event_title), e.event_url %>

    </dt>

    <dd class="<%= "grouped" if in_group %>">

      <span class="description"><%= format_activity_description(e.event_description) %></span>

      <span class="author"><%= link_to_user(e.event_author) if e.respond_to?(:event_author) %></span>

    </dd>

  <%- else -%>

    <dt class="<%= e.event_type %>  <%= User.current.logged? && e.respond_to?(:event_author) && User.current == e.event_author ? 'me' : nil %>">

      <%= avatar(e.event_author, :size => "24") if e.respond_to?(:event_author) %>

      <span class="time"><%= format_time(e.event_datetime, false) %></span>

      <%= link_to format_activity_title(e.event_title), e.event_url %>

      was added to the following

      <% if e.projects.count > 1 %>

        projects:

      <%- else -%>

        project:

      <%- end -%>

      <%= content_tag('span', e.projects.join(', ')) -%>

    </dt>

    <dd>

      <span class="description"><%= e.event_description -%></span>

      <span class="author"><%= link_to_user(e.event_author) if e.respond_to?(:event_author) %></span>

    </dd>

  <% end -%>

<%- end -%>

</dl>

<% end -%>

</div>

<%= content_tag('p', l(:label_no_data), :class => 'nodata') if @events_by_day.empty? %>

<div style="float:left;">

<%= link_to_content_update("\xc2\xab " + l(:label_previous),

                   params.merge(:from => @date_to - @days - 1),

                   :title => l(:label_date_from_to, :start => format_date(@date_to - 2*@days), :end => format_date(@date_to - @days - 1))) %>

</div>

<div style="float:right;">

<%= link_to_content_update(l(:label_next) + " \xc2\xbb",

                   params.merge(:from => @date_to + @days - 1),

                   :title => l(:label_date_from_to, :start => format_date(@date_to), :end => format_date(@date_to + @days - 1))) unless @date_to >= Date.today %>

</div>

 

<% other_formats_links do |f| %>

  <%= f.link_to 'Atom', :url => params.merge(:from => nil, :key => User.current.rss_key) %>

<% end %>

<% content_for :header_tags do %>

<%= auto_discovery_link_tag(:atom, params.merge(:format => 'atom', :from => nil, :key => User.current.rss_key)) %>

<% end %>

<% content_for :sidebar do %>

<% form_tag({}, :method => :get) do %>

<h3><%= l(:label_activity) %></h3>

<ul>

<% @activity.event_types.each do |t| %>

  <li>

    <%= check_box_tag "show_#{t}", 1, @activity.scope.include?(t) %>

    <label for="show_<%=t%>">

      <%= link_to(l("label_#{t.singularize}_plural"),

                  {"show_#{t}" => 1, :user_id => params[:user_id], :from => params[:from]})%>

    </label>

  </li>

<% end %>

</ul>

<% if @project && @project.descendants.active.any? %>

    <%= hidden_field_tag 'with_subprojects', 0 %>

    <p><label><%= check_box_tag 'with_subprojects', 1, @with_subprojects %> <%=l(:label_subproject_plural)%></label></p>

<% end %>