SoundSoftware Code Site

  unloadable

  model_object Publication

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

  def new

    @publication.build_bibtex_entry

    # and at least one author

    @author_options = [["#{User.current.name} (@#{User.current.mail.partition('@')[2]})", "#{User.current.class.to_s}_#{User.current.id.to_s}"]]

  end

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

    @author_options = []

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

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

      @publication.notify_authors_publication_added(@project)

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

    # method for creating "pasted" bibtex entries

    if bibtex_entry

    end

  end

  def get_bibtex_required_fields

    unless params[:value].empty?

    end

    respond_to do |format|

      format.js {

          if params[:value].empty?

            page << "hideOnLoad();"

          else

    end

  end

    find_project_by_project_id unless params[:project_id].nil?

    @edit_view = true;

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

    @selected_bibtex_entry_type_id = @publication.bibtex_entry.entry_type

  end

    @author_options = []

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

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

      if !params[:project_id].nil?

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

      else

      end

    else

      render :action => 'edit'

  end

    return authors_entry.split(" and ")

  end

  def parse_bibtex_list(bibtex_list)

    bibliography = BibTeX.parse bibtex_list

        create_bibtex_entry d

      end

    end

    @publication = Publication.new

    authors = []

    institution = ""

    email = ""

      else

        @bentry[field] = d[field]

      end

    @publication.bibtex_entry = @bentry

    @publication.save

    # @created_publications << @publication.id

    # need to save all authors

    authors.each_with_index.map do |authorname, idx|

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

      if author.save!

  def autocomplete_for_project

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

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

    render :layout => false

  end

    @results = []

    object_id = params[:object_id]

    @results = users_list

      flag = true

      users_list.each do |user|

      @results << authorship if flag

    end

  end

  def get_user_info

    respond_to do |format|

      format.js {

          page[name_field].value = item.name

          page[email_field].value = item.mail

          page[institution_field].value = item.institution

  end

  def add_project

    @publication.projects << @projects

    respond_to do |format|

      format.html { redirect_to :back }

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

        }

      }

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

      end

    else

    end

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

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

  end

  def destroy

  def projects_check_box_tags(name, projects)

    s = ''

    projects.sort.each do |project|

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

        s << '<br />'

      end

    end

  end

  def choose_author_link(object_name, items)

    # called by autocomplete_for_author (publications' action/view)

    # creates the select list based on the results array

    # results is an array with both Users and Authorships objects

    @author_options = []

    @results.each do |result|

      email_bit = result.mail.partition('@')[2]

      end

      @author_options << ["#{result.name} #{email_bit}", "#{result.class.to_s}_#{result.id.to_s}"]

    end

   if @results.size > 0

     s = select_tag( form_tag_name(object_name, :author_search_results), options_for_select(@author_options), { :id => form_tag_id(object_name, :author_search_results), :size => 3} )

     s << observe_field( form_tag_id(object_name, :author_search_results), :on => 'click', :function => "alert('Element changed')", :with => 'q')

   else

     s = "<em>No Authors found that match your search… sorry!</em>"

  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|

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

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

  def sanitized_object_name(object_name)

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

  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)}]"

  end

    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

    s = '<p>'

    publication.authorships.each do |authorship|

      s << link_to_authorship(authorship)

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

  end

    s= ""

    publication.projects.visible.each do |proj|

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

        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

      end

  end

  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 << "<p>"

      if key == "entry_type"

        s << bibtex_entry.entry_type_label

      s << "</p>"

    end

    s

end

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

  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

  # Ensure error message uses proper text instead of

    end

  end

    self.authors.each do |author|

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

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

    end

  end

    self.authors.each do |author|

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

      Mailer.deliver_publication_updated(author.user, self, project) 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

  def print_bibtex_author_names

    # already outputs the author names ASC by auth_order

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

  def print_entry(style)

    bib = BibTeX::Entry.new

    bib.author = self.print_bibtex_author_names

    bib.title = self.title

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

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

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

      else

        bib[key.to_sym] = value

    end

    if style == :ieee

      bibtex = bib.to_s :include => :meta_content

      bibtex.strip!

      logger.error { bibtex }

  end

end

    <div class="box">

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

       <dt>

       </dt>

       <dd>

       </dd>

       <dd class="bibtex-textarea collapsed" style="display: none;">

       </dd>

   <% end -%>

     </dl>

<div class="box">

  <h3>Publication Info</h3>

  <h3>B<small>IB</small>T<sub>E</sub>X Format</h3>

</div>

<div class="box">

require 'bibtex'

require 'citeproc'

# Patches to the Redmine core.

Dispatcher.to_prepare :redmine_model_dependencies do

  require_dependency 'project'

    Mailer.send(:include, Bibliography::MailerPatch)

  end

end

  # extending the Project Menu

  menu :project_menu, :publications, { :controller => 'publications', :action => 'index', :path => nil }, :after => :activity, :param => :project_id, :caption => Proc.new { Setting.plugin_redmine_bibliography['menu'] },

   :if => Proc.new { !Setting.plugin_redmine_bibliography['menu'].blank? }

end

require_dependency 'user'

module Bibliography

    def self.included(base)

    end #self.included

    module ClassMethods

    module InstanceMethods

      def institution

          institution_name = self.ssamr_user_detail.institution_name

        else

          institution_name = "No Institution Set"

      end

      def get_author_info

        # TODO: DELETE THIS METHOD??

          :name_on_paper =>  self.name,

          :email => self.mail,

          :institution => "",

          :author_user_id => self.id,

        }

        if not self.ssamr_user_detail.nil?

          info[:institution]  = self.ssamr_user_detail.institution_name

        end

      end

    end #InstanceMethods

  end #UserPublicationsPatch

end #RedmineBibliography

module RedmineTags

  module Patches

      def self.included(base)

        base.send(:include, InstanceMethods)

          skip_before_filter :authorize, :only => [:set_fieldset_status]

          skip_before_filter :find_project, :only => [:set_fieldset_status]

          before_filter :add_tags_to_project, :only => [:save, :update]

          alias :index filtered_index

        end

      end

      module InstanceMethods

        def add_tags_to_project

          if params && params[:project] && !params[:project][:tag_list].nil?

          else

            @myproj_status = session[:my_projects_fieldset_status]

          end

          if session[:filters_fieldset_status].nil?

            @filter_status = "false"

          else

            @filter_status = session[:filters_fieldset_status]

          end

          if params && params[:project] && !params[:project][:tag_list].nil?

            @filter_status = "true"

          end

        end

        # Lists visible projects. Paginator is for top-level projects only

          get_fieldset_statuses

          respond_to do |format|

              paginate_projects

              if User.current.logged?

                # seems sort_by gives us case-sensitive ordering, which we don't want

                #          @user_projects = User.current.projects.sort_by(&:name)

                @user_projects = User.current.projects.all(:order => :name)

              end

              render :template => 'projects/index.html.erb', :layout => !request.xhr?

            }

            format.api {

        private

          if params.has_key?(:project)

            @tag_list = (params[:project][:tag_list] || "").strip.split(",")

          else

            @projects = Project.visible_roots.find(Project.visible.search_by_question(@question))

          end

          unless @tag_list.empty?

            @tagged_projects_ids = Project.visible.tagged_with(@tag_list).collect{ |project| Project.find(project.id).root }

            @projects = @projects & @tagged_projects_ids

      def self.included(base) # :nodoc:

        base.send(:include, InstanceMethods)

        base.class_eval do

          unloadable

        end

      end

        # Renders a tree of projects that the current user does not belong

        # to, or of all projects if the current user is not logged in.  The

        # given collection may be a subset of the whole project tree

        # description, manager(s), creation date, last activity date,

        # general activity level, whether there is anything actually hosted

        # here for the project, etc.

          custom_fields = ""

          s = ""

          if projects.any?

            tokens = RedmineProjectFiltering.calculate_tokens(question, custom_fields)

            s << "<div class='autoscroll'>"

            s << "<table class='list projects'>"

            s << "<thead><tr>"

            s << sort_header_tag('name', :caption => l("field_name"))

            s << "<th class='tags'>" << l("tags") << "</th>"

            s << "<th class='managers'>" << l("label_managers") << "</th>"

            s << sort_header_tag('created_on', :default_order => 'desc')

            s << sort_header_tag('updated_on', :default_order => 'desc')

            s << "</tr></thead><tbody>"

            original_project = @project

            projects.each do |project|

              s << render_project_in_table_with_filtering(project, cycle('odd', 'even'), 0, tokens)

            end

            s << "</table>"

          else

            s << "\n"

          s

        end

          # set the project environment to please macros.

          @project = project

          s << "<td class='tags' align=top>" << project.tag_counts.collect{ |t| render_project_tag_link(t) }.join(', ') << "</td>"

          s << "<td class='managers' align=top>"

          u = project.users_by_role

          if u

            u.keys.each do |r|

          end

          s << "</td>"

          s << "<td class='created_on' align=top>" << format_date(project.created_on) << "</td>"

          s << "<td class='updated_on' align=top>" << format_date(project.updated_on) << "</td>"

          s

        end

        # Renders a tree of projects as a nested set of unordered lists

        # The given collection may be a subset of the whole project tree

        # (eg. some intermediate nodes are private and can not be seen)

          if projects.any?

            tokens = RedmineProjectFiltering.calculate_tokens(question, custom_fields)

            debugger

            ancestors = []

            original_project = @project

              else

                ancestors.pop

                s << "</li>"

                  ancestors.pop

                  s << "</ul></li>"

                end

              end

              classes = (ancestors.empty? ? 'root' : 'child')

              s << "<li class='#{classes}'><div class='#{classes}'>" +

                  {:controller => 'projects', :action => 'show', :id => project},

                  :class => "project #{User.current.member_of?(project) ? 'my-project' : nil}"

                )

           #    value = value_model.present? ? value_model.value : nil

           #    s << "<li><b>#{field.name.humanize}:</b> #{highlight_tokens(value, tokens)}</li>" if value.present?

           #  end

              s << "</ul>"

              s << "<div class='clear'></div>"

              unless project.description.blank?

          end

          s.join "\n"

        end

        # Renders a tree of projects where the current user belongs

        # as a nested set of unordered lists

        # The given collection may be a subset of the whole project tree

          s

        end

        def render_my_project_in_hierarchy_with_tags(project)

            else

              s << " <span class='private'>" << l(:field_is_private) << "</span>"

            end

            tc = project.tag_counts

            if tc.empty?

              s << " <span class='no-tags'>" << l(:field_no_tags) << "</span>"

        end

        private

        # copied from search_helper. This one doesn't escape html or limit the text length

        def highlight_tokens(text, tokens)

          return text unless text && tokens && !tokens.empty?

          re_tokens = tokens.collect {|t| Regexp.escape(t)}

          result = ''

          text.split(regexp).each_with_index do |words, i|

            words = words.mb_chars

          end

          result

        end

      end

    end

  end