Redmine

# Tags

gem 'acts-as-taggable-on', '~> 6.0'

  acts_as_taggable

    @tags_list = nil

    'tag_list',

  def tags_list

    if @tags_list

      @tags_list

    else

      tag_list

    end

  end

  # Preloads tags for a collection of issues

  def self.load_issues_tags(issues)

    if issues.any?

      tags = ActsAsTaggableOn::Tag.joins(:taggings)

      .select("#{ActsAsTaggableOn::Tag.table_name}.id", "#{ActsAsTaggableOn::Tag.table_name}.name", 

        "#{ActsAsTaggableOn::Tagging.table_name}.taggable_id")

      .where(:taggings => {:taggable_type => 'Issue', :taggable_id => issues.map(&:id), :context => 'tags'})

      .sort

      issues.each do |issue|

        issue.instance_variable_set "@tags_list", (tags.select{|t| t.taggable_id == issue.id} || [])

      end

    end

  end

    QueryColumn.new(:tags_list, :caption => :field_tags),

    add_available_filter('tags_list', :type => :list_optional, :name => l(:field_tags),

      :values => lambda { tags_values })

    if has_column?(:tags_list)

      Issue.load_issues_tags(issues)

    end

  def sql_for_tags_list_field(field, operator, value)

    case operator

      when '=', '!'

        issues = Issue.tagged_with(values_for('tags_list'), any: true)

      when '!*'

        issues = Issue.tagged_with ActsAsTaggableOn::Tag.all.map(&:to_s), exclude: true

      else

        issues = Issue.tagged_with ActsAsTaggableOn::Tag.all.map(&:to_s), any: true

    end

      compare = operator.eql?('!') ? 'NOT IN' : 'IN'

      issue_ids = issues.collect {|issue| issue.id }.push(0).join(',')

      "( #{ Issue.table_name }.id #{ compare } (#{ issue_ids }) )"

  end

      @tag_list_before_change = journalized.tag_list

    if @tag_list_before_change

      new_tags = journalized.send('tag_list')

      if new_tags != @tag_list_before_change

        add_attribute_detail('tags', @tag_list_before_change.to_s, new_tags.to_s)

      end

    end

  def tags_values

    issues_scope = Issue.visible.select("#{Issue.table_name}.id").joins(:project)

    issues_scope.where("#{project.project_condition(Setting.display_subprojects_issues?)}") if project

    result_scope = ActsAsTaggableOn::Tag

      .joins(:taggings)

      .select('tags.name')

      .group('tags.id, tags.name')

      .where(taggings: { taggable_type: 'Issue', taggable_id: issues_scope})

      .collect {|t| [t.name, t.name]}

    result_scope

  end

<p><%= f.text_field :tag_list, :size => 60, :value => @issue.tag_list.to_s %>

<% unless @issue.tag_list.empty? %>

  <div class="tags attribute">

    <div class="label">

      <span><%= l(:field_tags) %>:</span>

    </div>

    <div class="value">

      <%= @issue.tag_list.to_s %>

    </div>

  </div>

<% end %>

  field_tags: Tags

# This migration comes from acts_as_taggable_on_engine (originally 1)

if ActiveRecord.gem_version >= Gem::Version.new('5.0')

  class ActsAsTaggableOnMigration < ActiveRecord::Migration[4.2]; end

else

  class ActsAsTaggableOnMigration < ActiveRecord::Migration; end

end

ActsAsTaggableOnMigration.class_eval do

  def self.up

    create_table :tags do |t|

      t.string :name

    end

    create_table :taggings do |t|

      t.references :tag

      # You should make sure that the column created is

      # long enough to store the required class names.

      t.references :taggable, polymorphic: true

      t.references :tagger, polymorphic: true

      # Limit is created to prevent MySQL error on index

      # length for MyISAM table type: http://bit.ly/vgW2Ql

      t.string :context, limit: 128

      t.datetime :created_at

    end

    add_index :taggings, :tag_id

    add_index :taggings, [:taggable_id, :taggable_type, :context]

  end

  def self.down

    drop_table :taggings

    drop_table :tags

  end

end

# This migration comes from acts_as_taggable_on_engine (originally 2)

if ActiveRecord.gem_version >= Gem::Version.new('5.0')

  class AddMissingUniqueIndices < ActiveRecord::Migration[4.2]; end

else

  class AddMissingUniqueIndices < ActiveRecord::Migration; end

end

AddMissingUniqueIndices.class_eval do

  def self.up

    add_index :tags, :name, unique: true

    remove_index :taggings, :tag_id if index_exists?(:taggings, :tag_id)

    remove_index :taggings, [:taggable_id, :taggable_type, :context]

    add_index :taggings,

              [:tag_id, :taggable_id, :taggable_type, :context, :tagger_id, :tagger_type],

              unique: true, name: 'taggings_idx'

  end

  def self.down

    remove_index :tags, :name

    remove_index :taggings, name: 'taggings_idx'

    add_index :taggings, :tag_id unless index_exists?(:taggings, :tag_id)

    add_index :taggings, [:taggable_id, :taggable_type, :context]

  end

end

# This migration comes from acts_as_taggable_on_engine (originally 3)

if ActiveRecord.gem_version >= Gem::Version.new('5.0')

  class AddTaggingsCounterCacheToTags < ActiveRecord::Migration[4.2]; end

else

  class AddTaggingsCounterCacheToTags < ActiveRecord::Migration; end

end

AddTaggingsCounterCacheToTags.class_eval do

  def self.up

    add_column :tags, :taggings_count, :integer, default: 0

    ActsAsTaggableOn::Tag.reset_column_information

    ActsAsTaggableOn::Tag.find_each do |tag|

      ActsAsTaggableOn::Tag.reset_counters(tag.id, :taggings)

    end

  end

  def self.down

    remove_column :tags, :taggings_count

  end

end

# This migration comes from acts_as_taggable_on_engine (originally 4)

if ActiveRecord.gem_version >= Gem::Version.new('5.0')

  class AddMissingTaggableIndex < ActiveRecord::Migration[4.2]; end

else

  class AddMissingTaggableIndex < ActiveRecord::Migration; end

end

AddMissingTaggableIndex.class_eval do

  def self.up

    add_index :taggings, [:taggable_id, :taggable_type, :context]

  end

  def self.down

    remove_index :taggings, [:taggable_id, :taggable_type, :context]

  end

end

# This migration comes from acts_as_taggable_on_engine (originally 5)

# This migration is added to circumvent issue #623 and have special characters

# work properly

if ActiveRecord.gem_version >= Gem::Version.new('5.0')

  class ChangeCollationForTagNames < ActiveRecord::Migration[4.2]; end

else

  class ChangeCollationForTagNames < ActiveRecord::Migration; end

end

ChangeCollationForTagNames.class_eval do

  def up

    if ActsAsTaggableOn::Utils.using_mysql?

      execute("ALTER TABLE tags MODIFY name varchar(255) CHARACTER SET utf8 COLLATE utf8_bin;")

    end

  end

end

# This migration comes from acts_as_taggable_on_engine (originally 6)

if ActiveRecord.gem_version >= Gem::Version.new('5.0')

  class AddMissingIndexesOnTaggings < ActiveRecord::Migration[4.2]; end

else

  class AddMissingIndexesOnTaggings < ActiveRecord::Migration; end

end

AddMissingIndexesOnTaggings.class_eval do

  def change

    add_index :taggings, :tag_id unless index_exists? :taggings, :tag_id

    add_index :taggings, :taggable_id unless index_exists? :taggings, :taggable_id

    add_index :taggings, :taggable_type unless index_exists? :taggings, :taggable_type

    add_index :taggings, :tagger_id unless index_exists? :taggings, :tagger_id

    add_index :taggings, :context unless index_exists? :taggings, :context

    unless index_exists? :taggings, [:tagger_id, :tagger_type]

      add_index :taggings, [:tagger_id, :tagger_type]

    end

    unless index_exists? :taggings, [:taggable_id, :taggable_type, :tagger_id, :context], name: 'taggings_idy'

      add_index :taggings, [:taggable_id, :taggable_type, :tagger_id, :context], name: 'taggings_idy'

    end

  end

end

          tags = issue.tags_list

          if tags.any?

            pdf.SetFontStyle('B',9)

            pdf.RDMCell(35+155, 5, l(:field_tags), "LRT", 1)

            pdf.SetFontStyle('',9)

            pdf.SetFontStyle('',9)

            pdf.RDMwriteHTMLCell(35+155, 5, '', '', tags.to_s, '', "LRB")

          end

              when :tags_list

                value = value.to_s

---

tagging_1:

  tag_id: 1

  taggable_id: 1

  taggable_type: Issue

  context: tags

  created_at: <%= 2.days.ago.to_s(:db) %>

tagging_2:

  tag_id: 2

  taggable_id: 1

  taggable_type: Issue

  context: tags

  created_at: <%= 2.days.ago.to_s(:db) %>

tagging_3:

  tag_id: 1

  taggable_id: 2

  taggable_type: Issue

  context: tags

  created_at: <%= 2.days.ago.to_s(:db) %>

---

tag_001:

  id: 1

  name: UX

tag_002:

  id: 2

  name: Backend

tag_003:

  id: 3

  name: API

           :changesets,

           :tags,

           :taggings

  def  test_index_with_tags_column

    get :index, :params => {

        :set_filter => 1,

        :project_id => 1,

        :c => %w(subject tags_list)

      }

      assert_response :success

      assert_select 'td.tags_list', :text => 'UX'

      assert_select 'td.tags_list', :text => 'UX, Backend'

      get :index, :params => {

          :set_filter => 1,

          :project_id => 1,

          :c => %w(subject tags_list),

          :format => 'pdf'

        }

      assert_response :success

      assert_equal 'application/pdf', response.content_type

  end

  def test_show_should_render_issue_tags_for_issue_with_tags

    @request.session[:user_id] = 1

    get :show, :params => {

        :id => 1

      }

    assert_response :success

    assert_select 'div.tags .value', :text => 'UX, Backend', :count => 1

  end

  def test_show_should_not_render_issue_tags_for_issue_without_tags

    @request.session[:user_id] = 1

    get :show, :params => {

        :id => 14

      }

    assert_response :success

    assert_select 'div.tags', 0

  end

      assert_select 'input[name=?]', 'issue[tag_list]'

  def test_post_create_with_tags

    @request.session[:user_id] = 2

    post :create, :params => {

        :project_id => 1,

        :issue => {

          :tracker_id => 1,

          :subject => 'This is a new issue with tags',

          :description => 'This is the description',

          :priority_id => 5,

          :tag_list => 'Two, Three'

        }

      }

    issue = Issue.order('id DESC').first

    assert_equal ['Two', 'Three'], issue.tag_list

  end

  def test_put_update_issue_tags

    @request.session[:user_id] = 1

    put :update, :params => {

        :id => 1,

        :issue => {

          :tag_list => 'Three'

        }

      }

    assert_response 302

    assert_equal ['Three'], Issue.find(1).tag_list

  end

           :queries, :tags, :taggings

  def test_filter_with_tags_should_return_filter_values

    @request.session[:user_id] = 2

    get :filter, :params => {

        :project_id => 1,

        :type => 'IssueQuery',

        :name => 'tags_list'

      }

    assert_response :success

    assert_equal 'application/json', response.content_type

    json = ActiveSupport::JSON.decode(response.body)

    assert_equal [["UX","UX"],["Backend","Backend"]], json

  end

# Redmine - project management software

# Copyright (C) 2006-2017  Jean-Philippe Lang

#

# This program 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 2

# of the License, or (at your option) any later version.

#

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require File.expand_path('../../test_helper', __FILE__)

class IssueTagsTest < ActiveSupport::TestCase

  fixtures :projects, :users, :email_addresses, :user_preferences, :members, :member_roles, :roles,

           :groups_users,

           :trackers, :projects_trackers,

           :enabled_modules,

           :issue_statuses,

           :issues, :journals, :journal_details,

           :tags, :taggings

  include Redmine::I18n

  def setup

    set_language_if_valid 'en'

  end

  def teardown

    User.current = nil

  end

  def test_issue_tag_list_should_return_an_array_of_tags

    assert_equal ['UX', 'Backend'], Issue.find(1).tag_list

  end

  def test_issue_tag_list_to_s_should_return_a_string_of_tags_delimited_by_comma

    assert_equal 'UX, Backend', Issue.find(1).tag_list.to_s

  end

  def test_add_issue_tags

    issue = Issue.find(2)

    issue.tag_list = "One, Two"

    assert issue.save!

    issue.reload

    assert_equal ['One', 'Two'], issue.tag_list

  end

  def test_clear_issue_tags

    issue = Issue.find(1)

    issue.tag_list = ''

    assert issue.save!

    assert_equal [], issue.tag_list

  end

  def test_update_issue_tags_should_journalize_changes

    issue = Issue.find(1)

    issue.init_journal User.find(1)

    issue.tag_list = "UX, API"

    assert_difference 'Journal.count', 1 do

      assert_difference 'JournalDetail.count', 1 do

        issue.save!

      end

    end

    issue.reload

    assert_equal ['UX', 'API'], issue.tag_list

    detail = JournalDetail.order('id DESC').first

    assert_equal issue, detail.journal.journalized

    assert_equal 'attr', detail.property

    assert_equal 'tags', detail.prop_key

    assert_equal 'UX, Backend', detail.old_value

    assert_equal 'UX, API', detail.value

  end

  def test_update_issue_tags_should_not_journalize_changes_if_tags_are_not_changed

    issue = Issue.find(1)

    issue.init_journal User.find(1)

    issue.tag_list = "UX, Backend"

    assert_difference 'Journal.count', 0 do

      assert_difference 'JournalDetail.count', 0 do

        issue.save!

      end

    end

  end

end

           :enabled_modules, :issues, :trackers, :enumerations,

           :tags, :taggings

  def test_fetch_row_values_should_return_issue_tags_as_string

    query = IssueQuery.new(:project => Project.find(1), :name => '_')

    query.column_names = [:subject, :tags_list]

    results = fetch_row_values(Issue.find(1), query, 0)

    assert_equal ["1", "Cannot print recipes", "UX, Backend"], results

  end

           :attachments,

           :tags, :taggings

  def test_filter_by_tags_with_operator_is

    query = IssueQuery.new(:name => '_')

    filter_name = "tags_list"

    assert_include filter_name, query.available_filters.keys

    query.filters = {filter_name => {:operator => '=', :values => ['UX']}}

    assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort

    # Should return issue tagged with any of the values

    query.filters = {filter_name => {:operator => '=', :values => ['UX, Backend']}}

    assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort

  end

  def test_filter_by_tags_with_operator_is_not

    query = IssueQuery.new(:name => '_')

    filter_name = "tags_list"

    assert_include filter_name, query.available_filters.keys

    query.filters = {filter_name => {:operator => '!', :values => ['Backend']}}

    issues = find_issues_with_query(query).map(&:id).sort

    # Issue tagged with Backend should not be returned

    assert_not_include 1, issues

    assert_include 2, issues

    # Untagged issues should be returned

    assert_include 5, issues

  end

  def test_filter_by_tags_with_operator_none

    query = IssueQuery.new(:name => '_')

    filter_name = "tags_list"

    assert_include filter_name, query.available_filters.keys

    query.filters = {filter_name => {:operator => '!*', :values => ['']}}

    issues = find_issues_with_query(query).map(&:id).sort

    # Tagged issues should not be returned

    assert_not_include 1, issues

    assert_not_include 2, issues

    # Untagged issues should be returned

    assert_include 5, issues

  end

  def test_filter_by_tags_with_operator_any

    query = IssueQuery.new(:name => '_')

    filter_name = "tags_list"

    assert_include filter_name, query.available_filters.keys

    query.filters = {filter_name => {:operator => '*', :values => ['']}}

    assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort

  end

  def test_query_should_preload_tags

    q = IssueQuery.new(:name => '_', :column_names => [:subject, :tags_list])

    assert q.has_column?(:tags_list)

    issues = q.issues

    assert_not_nil issues.first.instance_variable_get("@tags_list")

  end