SoundSoftware Code Site

          unloadable

          attr_accessor :tag_list

          acts_as_taggable

        end

      end

      module InstanceMethods

      end

      module ClassMethods

          name_like = options[:name_like]

          options = {}

          visible   = ARCondition.new

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

          if name_like

          options[:conditions] = visible.conditions

        end

      end

    end

require_dependency 'projects_controller'

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]

      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?

            @projects = @projects & @tagged_projects_ids

          end

        end

      end

    end

      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