SoundSoftware Code Site

# 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

        def project_search_tags

          @name = params[:q].to_s

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

          render :layout => false, :partial => 'search_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 

          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]

#          before_filter :filter_projects, :only => :index

          alias :index filtered_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

        def paginate_projects

          sort_init 'name'

          sort_update %w(name lft created_on updated_on)

          @limit = per_page_option

          @project_count = Project.visible_roots.find(@projects).count

          @project_pages = ActionController::Pagination::Paginator.new self, @project_count, @limit, params['page']

          @offset ||= @project_pages.current.offset

        end

        def set_fieldset_status

          # luisf. test for missing parameters………

          field = params[:field_id]

          status = params[:status]

          session[(field + "_status").to_sym] = status

          render :nothing => true

        end

        # gets the status of the collabsible fieldsets

        def get_fieldset_statuses

          if session[:my_projects_fieldset_status].nil?

            @myproj_status = "true"

          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

        # (subprojects belong to them)

        def filtered_index

          @project = Project.new

          filter_projects

          get_fieldset_statuses

          respond_to do |format|

            format.html { 

              paginate_projects

              @projects = Project.visible_roots.find(@projects, :offset => @offset, :limit => @limit, :order => sort_clause) 

              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.rhtml', :layout => !request.xhr?

            }

            format.api {

              @offset, @limit = api_offset_and_limit

              @project_count = Project.visible.count

              @projects = Project.visible.find(@projects, :offset => @offset, :limit => @limit, :order => 'lft')

            }

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

            }

            format.js {

              paginate_projects

              @projects = Project.visible_roots.find(@projects, :offset => @offset, :limit => @limit, :order => sort_clause)

              render :update do |page|

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

              end

            }

          end

        end

        private

        def filter_projects                  

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

          if params.has_key?(:project)

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

          else

            @tag_list = []

          end

          if  @question == ""

            @projects = Project.visible

          else

            @projects = 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) }

            @projects = @projects & @tagged_projects_ids

          end

          @projects = @projects.collect{ |project| project.root }

          @projects = @projects.uniq

        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)          

          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 << highlight_tokens(render_project_short_description(project), tokens)

          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

        # 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

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

        def render_my_project_hierarchy_with_tags(projects)

          s = ''

          original_project = @project

          projects.each do |project|

            if project.root? || !projects.include?(project.parent)

              s << render_my_project_in_hierarchy_with_tags(project)

            end

          end

          @project = original_project

          if s != ''

            a = ''

            a << "<ul class='projects root'>\n"

            a << s

            a << "</ul>\n"

            s = a

          end

          s

        end

        def render_my_project_in_hierarchy_with_tags(project)

          s = ''

          if User.current.member_of?(project)

            # set the project environment to please macros.

            @project = project

            classes = (project.root? ? 'root' : 'child')

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

              link_to_project(project, {}, :class => "project my-project")

            if project.is_public?

              s << " <span class='public'>" << l("field_is_public") << "</span>"

            else

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

            end

            s << render_project_short_description(project)

            s << l(:tags) << ":&nbsp"

            s << project.tag_counts.collect{ |t| render_project_tag_link(t) }.join(', ')

            s << "</div>\n"

            cs = ''

            project.children.each do |child|

              cs << render_my_project_in_hierarchy(child)

            end

            if cs != ''

              s << "<ul class='projects'>\n" << cs << "</ul>\n";

            end

          end

          s

        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