SoundSoftware Code Site

module RedmineProjectFiltering

  # transforms a question and a list of custom fields into something that Project.search can process

  def self.calculate_tokens(question, custom_fields=nil)

    list = []

    list << question if question.present?

    tokens = list.join(' ').scan(%r{((\s|^)"[\s\w]+"(\s|$)|\S+)})

    tokens = tokens.collect{ |m| m.first.gsub(%r{(^\s*"\s*|\s*"\s*$)}, '') }

    # tokens must be at least 2 characters long

    tokens.select {|w| w.length > 1 }

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Eric Davis

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

module RedmineTags

  module Hooks

    class ModelIssueHook < Redmine::Hook::ViewListener

      def controller_issues_edit_before_save(context={})

        save_tags_to_issue(context, true)

      end

      # Issue has an after_save method that calls reload (update_nested_set_attributes)

      # This makes it impossible for a new record to get a tag_list, it's

      # cleared on reload. So instead, hook in after the Issue#save to update

      # this issue's tag_list and call #save ourselves.

      def controller_issues_new_after_save(context={})

        save_tags_to_issue(context, false)

        context[:issue].save

      end

      def save_tags_to_issue(context, create_journal)

        params = context[:params]

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

          old_tags = context[:issue].tag_list.to_s

          context[:issue].tag_list = params[:issue][:tag_list]

          new_tags = context[:issue].tag_list.to_s

          if create_journal and not (old_tags == new_tags || context[:issue].current_journal.blank?)

            context[:issue].current_journal.details << JournalDetail.new(:property => 'attr',

                                                                         :prop_key => 'tag_list',

                                                                         :old_value => old_tags,

                                                                         :value => new_tags)

          end

        end

      end

    end

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Eric Davis

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

module RedmineTags

  module Hooks

    class ModelProjectHook < Redmine::Hook::ViewListener

      def controller_project_before_save(context={})

        debugger

        save_tags_to_project(context, true)

      end

      # Issue has an after_save method that calls reload (update_nested_set_attributes)

      # This makes it impossible for a new record to get a tag_list, it's

      # cleared on reload. So instead, hook in after the Issue#save to update

      # this issue's tag_list and call #save ourselves.

      def controller_projects_before_save(context={})

        debugger

        save_tags_to_project(context, false)

        context[:project].save

      end

      def save_tags_to_project(context, create_journal)

        params = context[:params]

        debugger

        logger.error { "WORKING" }

   #     if params && params[:issue] && !params[:issue][:tag_list].nil?

   #       old_tags = context[:issue].tag_list.to_s

   #       context[:issue].tag_list = params[:issue][:tag_list]

   #       new_tags = context[:issue].tag_list.to_s

   #

   #       if create_journal and not (old_tags == new_tags || context[:issue].current_journal.blank?)

   #         context[:issue].current_journal.details << JournalDetail.new(:property => 'attr',

   #                                                                      :prop_key => 'tag_list',

   #                                                                      :old_value => old_tags,

   #                                                                      :value => new_tags)

   #       end

   #     end

      end

    end

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

module RedmineTags

  module Hooks

    class ViewsIssuesHook < Redmine::Hook::ViewListener

      render_on :view_issues_show_details_bottom, :partial => 'issues/tags'

      render_on :view_issues_form_details_bottom, :partial => 'issues/tags_form'

      render_on :view_issues_sidebar_planning_bottom, :partial => 'issues/tags_sidebar'

    end

  end

end

module RedmineTags

  module Hooks

    class ViewsProjectsHook < Redmine::Hook::ViewListener

      render_on :view_projects_form, :partial => 'projects/tags_form'

      render_on :view_projects_show_left, :partial => 'projects/tags'

#      render_on :view_issues_sidebar_planning_bottom, :partial => 'issues/tags_sidebar'

    end

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

require_dependency 'auto_completes_controller'

module RedmineTags

  module Patches

    module AutoCompletesControllerPatch

      def self.included(base)

        base.send(:include, InstanceMethods)

      end

      module InstanceMethods

        def issue_tags

          @name = params[:q].to_s

          @tags = Issue.available_tags :project_id => @project, :name_like => @name

          render :layout => false, :partial => 'tag_list'

        end

        def project_tags

          @name = params[:q].to_s

          @tags = Project.available_tags :name_like => @name

          render :layout => false, :partial => 'tag_list'

        end

      end

    end

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

require_dependency 'issue'

module RedmineTags

  module Patches

    module IssuePatch

      def self.included(base)

        base.extend(ClassMethods)

        base.class_eval do

          unloadable

          acts_as_taggable

        end

      end

      module ClassMethods

        # Returns available issue tags

        # === Parameters

        # * <i>options</i> = (optional) Options hash of

        #   * project   - Project to search in.

        #   * open_only - Boolean. Whenever search within open issues only.

        #   * name_like - String. Substring to filter found tags.

        def available_tags(options = {})

          project   = options[:project]

          open_only = options[:open_only]

          name_like = options[:name_like]

          options   = {}

          visible   = ARCondition.new

          if project

            project = project.id if project.is_a? Project

            visible << ["#{Issue.table_name}.project_id = ?", project]

          end

          if open_only

            visible << ["#{Issue.table_name}.status_id IN " +

                        "( SELECT issue_status.id " + 

                        "    FROM #{IssueStatus.table_name} issue_status " +

                        "   WHERE issue_status.is_closed = ? )", false]

          end

          if name_like

            visible << ["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", "%#{name_like.downcase}%"]

          end

          options[:conditions] = visible.conditions

          self.all_tag_counts(options)

        end

      end

    end

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

require_dependency 'issues_helper'

module RedmineTags

  module Patches

    module IssuesHelperPatch

      def self.included(base)

        base.send(:include, InstanceMethods)

      end

      module InstanceMethods

        include TagsHelper

        def redmine_tags_settings

            @redmine_tags_settings = Setting.plugin_redmine_tags unless @redmine_tags_settings

            @redmine_tags_settings

        end

        def sidebar_tags

          unless @sidebar_tags

            @sidebar_tags = []

            if :none != redmine_tags_settings[:issues_sidebar].to_sym

              @sidebar_tags = Issue.available_tags(:project => @project,

                                                   :open_only => (redmine_tags_settings[:issues_open_only].to_i == 1))

            end

          end

          @sidebar_tags

        end

        def render_sidebar_tags

          render_tags_list(sidebar_tags,

                          :show_count => (redmine_tags_settings[:issues_show_count].to_i == 1),

                          :open_only => (redmine_tags_settings[:issues_open_only].to_i == 1),

                          :style => redmine_tags_settings[:issues_sidebar].to_sym)

        end

      end

    end

  end

end

# C4DM

require_dependency 'project'

module RedmineTags

  module Patches

    module ProjectPatch

      def self.included(base) # :nodoc:

        base.extend(ClassMethods)

        base.send(:include, InstanceMethods)

        base.class_eval do

          unloadable

          attr_accessor :tag_list

          acts_as_taggable

        end

      end

      def before_save_with_save_tags()

#        debugger

        logger.error { "GONNA SAVE TAG LIST" }

#        params[:tag_list]

        # logger.error { @project.name }

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

    #      old_tags = context[:project].tag_list.to_s

    #      context[:project].tag_list = params[:project][:tag_list]

    #      new_tags = context[:project].tag_list.to_s

    #

    #      unless (old_tags == new_tags || context[:project].current_journal.blank?)

    #        context[:project].current_journal.details << JournalDetail.new(:property => 'attr',

    #                                                                     :prop_key => 'tag_list',

    #                                                                     :old_value => old_tags,

    #                                                                     :value => new_tags)

    #      end

    #    end

      end

      module InstanceMethods

      end

      module ClassMethods

        def search_by_question(question)

          if question.length > 1

            search(RedmineProjectFiltering.calculate_tokens(question), nil, :all_words => true).first.sort_by(&:lft)

          else

            all(:order => 'lft')

          end

        end

        # Returns available project tags

        #  does not show tags from private projects

        def available_tags( options = {} )

          name_like = options[:name_like]

          options = {}

          visible   = ARCondition.new

          visible << ["#{Project.table_name}.is_public = \"1\""]

          if name_like

            visible << ["#{ActsAsTaggableOn::Tag.table_name}.name LIKE ?", "%#{name_like.downcase}%"]

          end

          options[:conditions] = visible.conditions

          self.all_tag_counts(options)          

        end

      end

    end

  end

end

require_dependency 'projects_controller'

module RedmineTags

  module Patches

    module ProjectsControllerPatch

      def self.included(base)

        base.send(:include, InstanceMethods)

        base.class_eval do          

          unloadable 

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

          before_filter :filter_projects, :only => :index                

        end

      end

      module InstanceMethods

        def add_tags_to_project

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

            old_tags = @project.tag_list.to_s

            new_tags = params[:project][:tag_list].to_s

            unless (old_tags == new_tags)

              @project.tag_list = new_tags

            end

          end

        end

        # # luisf - TO BE REMOVED?

        # def calculate_project_filtering_settings

        #   @project_filtering_settings = Setting[:plugin_redmine_project_filtering]

        # end

        def filter_projects

          @project = Project.new

          respond_to do |format|

            format.any(:html, :xml) {

              calculate_filtered_projects

            }

            format.js {

              calculate_filtered_projects

              render :update do |page|

                page.replace_html 'projects', :partial => 'filtered_projects'

              end

            }

            format.atom {

              projects = Project.visible.find(:all, :order => 'created_on DESC',

              :limit => Setting.feeds_limit.to_i)

              render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")

            }

          end

        end

        private

        def calculate_filtered_projects                  

          @question = (params[:q] || "").strip     

          if params.has_key?(:project)

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

          else

            @tag_list = []

          end

          @projects = Project.visible

          @featured_projects = @projects.featured if Project.respond_to? :featured

          # luisf 

          @projects = @projects.search_by_question(@question) unless @question == ""

          @tagged_projects_ids = Project.tagged_with(@tag_list).collect{ |project| Project.find(project.id) } unless @tag_list.empty?

          debugger

          # intersection of both prject groups            

          @projects = @projects && @tagged_projects_ids unless @tag_list.empty?

          @filtered_projects = @projects

        end

      end

    end

  end

end

module RedmineTags

  module Patches

    module ProjectsHelperPatch

      def self.included(base) # :nodoc:

        base.send(:include, InstanceMethods)

        base.class_eval do

          unloadable

        end

      end

      module InstanceMethods        

        # 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

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

        # are potentially interested in various things: the project name,

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

        # general activity level, whether there is anything actually hosted

        # here for the project, etc.

        def render_project_table_with_filtering(projects, question)

          debugger

          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='managers'>" << l("label_managers") << "</th>"

            s << "<th class='tags'>" << l("tags") << "</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"

          end

          @project = original_project

          s

        end

        def render_project_in_table_with_filtering(project, oddeven, level, tokens)          

          # set the project environment to please macros.

          @project = project

          classes = (level == 0 ? 'root' : 'child')

          s = ""

          s << "<tr class='#{oddeven} #{classes} level#{level}'>"

          s << "<td class='firstcol' align=top><div class='name hosted_here"

          s << " no_description" if project.description.blank?

          s << "'>" << link_to( highlight_tokens(project.name, tokens), {:controller => 'projects', :action => 'show', :id => project}, :class => "project #{User.current.member_of?(project) ? 'my-project' : nil}")

          s << "</div>"

          s << render_project_short_description(project)

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

          u = project.users_by_role

          if u

            u.keys.each do |r|

              if r.allowed_to?(:edit_project)

                mgrs = []

                u[r].sort.each do |m|

                  mgrs << link_to_user(m)

                end

                if mgrs.size < 3

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

                else

                  s << mgrs.join(', ')

                end

              end

            end

          end

          s << "</td>"

          # taglist

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

          project.children.each do |child|

            if child.is_public? or User.current.member_of?(child)

              s << render_project_in_table_with_filtering(child, oddeven, level + 1, tokens)

            end

          end

          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)

        def render_project_hierarchy_with_filtering(projects,custom_fields,question)

          s = []

          if projects.any?

            tokens = RedmineProjectFiltering.calculate_tokens(question, custom_fields)

            debugger

            ancestors = []

            original_project = @project

            projects.each do |project|

              # set the project environment to please macros.

              @project = project

              if (ancestors.empty? || project.is_descendant_of?(ancestors.last))

                s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>"

              else

                ancestors.pop

                s << "</li>"

                while (ancestors.any? && !project.is_descendant_of?(ancestors.last)) 

                  ancestors.pop

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

                end

              end

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

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

                link_to( highlight_tokens(project.name, tokens), 

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

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

                )

              s << "<ul class='filter_fields'>"

           #  CustomField.usable_for_project_filtering.each do |field|

           #    value_model = project.custom_value_for(field.id)

           #    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?

                s << "<div class='wiki description'>"

                s << "<b>#{ t(:field_description) }:</b>"

                s << highlight_tokens(textilizable(project.short_description, :project => project), tokens)

                s << "\n</div>"

              end

              s << "</div>"

              ancestors << project

            end

            ancestors.size.times{ s << "</li></ul>" }

            @project = original_project

          end

          s.join "\n"

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

          regexp = Regexp.new "(#{re_tokens.join('|')})", Regexp::IGNORECASE    

          result = ''

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

            words = words.mb_chars

            if i.even?

              result << words

            else

              t = (tokens.index(words.downcase) || 0) % 4

              result << content_tag('span', words, :class => "highlight token-#{t}")

            end

          end

          result

        end

      end

    end

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

require_dependency 'queries_helper'

module RedmineTags

  module Patches

    module QueriesHelperPatch

      def self.included(base)

        base.send(:include, InstanceMethods)

        base.class_eval do

          alias_method :column_content_original, :column_content

          alias_method :column_content, :column_content_extended

        end

      end

      module InstanceMethods

        include TagsHelper

        def column_content_extended(column, issue)

          if column.name.eql? :tags

            column.value(issue).collect{ |t| render_tag_link(t) }.join(', ')

          else

            column_content_original(column, issue)

          end

        end

      end

    end

  end

end

# This file is a part of redmine_tags

# redMine plugin, that adds tagging support.

#

# Copyright (c) 2010 Aleksey V Zapparov AKA ixti

#

# redmine_tags is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# redmine_tags is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with redmine_tags.  If not, see <http://www.gnu.org/licenses/>.

require_dependency 'query'

module RedmineTags

  module Patches

    module QueryPatch

      def self.included(base)

        base.send(:include, InstanceMethods)

        base.class_eval do

          unloadable

          alias_method :statement_original, :statement

          alias_method :statement, :statement_extended

          alias_method :available_filters_original, :available_filters

          alias_method :available_filters, :available_filters_extended

          base.add_available_column(QueryColumn.new(:tags))

        end

      end

      module InstanceMethods

        def statement_extended

          filter  = filters.delete 'tags'

          clauses = statement_original

          if filter

            filters.merge!( 'tags' => filter )

            values    = values_for('tags').clone

            compare   = operator_for('tags').eql?('=') ? 'IN' : 'NOT IN'

            ids_list  = Issue.tagged_with(values).collect{ |issue| issue.id }.push(0).join(',')

            clauses << " AND ( #{Issue.table_name}.id #{compare} (#{ids_list}) ) "

          end

          clauses

        end

        def available_filters_extended

          unless @available_filters 

            available_filters_original.merge!({ 'tags' => {

              :type   => :list,

              :order  => 6,

              :values => Issue.available_tags(:project => project).collect{ |t| [t.name, t.name] }

            }})

          end

          @available_filters

        end

      end

    end

  end

end