SoundSoftware Code Site

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

      cite = bib.to_citeproc

      cite_id = cite["id"]

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

      cp.import [cite]

      texts = cp.render :bibliography, id: cite_id

      texts[0]

    else

      bibtex = bib.to_s :include => :meta_content

      bibtex.strip!

    end

  end

end