additional_tags 1.0.0

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  files = FileList['test/**/*test.rb']
+  t.test_files = files
+  t.verbose = true
+end
+
+task default: :test

data/additional_tags.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path '../lib', __FILE__
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'additional_tags/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'additional_tags'
+  spec.version       = AdditionalTags::VERSION
+  spec.authors       = ['AlphaNodes']
+  spec.email         = ['alex@alphanodes.com']
+
+  spec.summary       = 'Redmine plugin for adding tag functionality'
+  spec.description   = 'Redmine plugin for adding tag functionality'
+  spec.homepage      = 'https://github.com/alphanodes/additional_tags'
+  spec.license       = 'GPL-2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^((test|spec|features)/|Gemfile)})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.4'
+
+  spec.add_runtime_dependency 'acts-as-taggable-on', '~> 6.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+end

data/app/controllers/additional_tags_controller.rb

@@ -0,0 +1,80 @@
+class AdditionalTagsController < ApplicationController
+  before_action :require_admin
+  before_action :find_tag, only: %i[edit update]
+  before_action :bulk_find_tags, only: %i[context_menu merge destroy]
+  before_action :set_tag_list_path
+
+  helper :additional_tags_issues
+
+  def edit; end
+
+  def destroy
+    @tags.each do |tag|
+      begin
+        tag.reload.destroy
+      rescue ::ActiveRecord::RecordNotFound
+        Rails.logger.warn "Tag #{tag} could not be deleted"
+      end
+    end
+    redirect_back_or_default @tag_list_path
+  end
+
+  def update
+    @tag.name = params[:tag][:name] if params[:tag]
+    if @tag.save
+      flash[:notice] = l :notice_successful_update
+      respond_to do |format|
+        format.html do
+          redirect_to @tag_list_path
+        end
+        format.xml
+      end
+    else
+      respond_to do |format|
+        format.html { render action: 'edit' }
+      end
+    end
+  end
+
+  def context_menu
+    @tag = @tags.first if @tags.size == 1
+    @back = back_url
+    render layout: false
+  end
+
+  def merge
+    return unless request.post? &&
+                  params[:tag].present? &&
+                  params[:tag][:name].present?
+
+    AdditionalTags::Tags.merge params[:tag][:name], @tags
+    redirect_to @tag_list_path
+  end
+
+  private
+
+  def set_tag_list_path
+    @tag_list_path = plugin_settings_path id: 'additional_tags', tab: 'manage_tags'
+  end
+
+  def bulk_find_tags
+    @tags = ActsAsTaggableOn::Tag.joins("JOIN #{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.taggings_table}" \
+                                        " ON #{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.taggings_table}.tag_id =" \
+                                        " #{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.id ")
+                                 .select("#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.id," \
+                                         "#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.name," \
+                                         "#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.taggings_count," \
+                                         " COUNT(DISTINCT #{ActsAsTaggableOn.taggings_table}.taggable_id) AS count")
+                                 .where(id: params[:id] ? [params[:id]] : params[:ids])
+                                 .group("#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.id" \
+                                        ", #{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.name" \
+                                        ", #{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.taggings_count")
+    raise ActiveRecord::RecordNotFound if @tags.empty?
+  end
+
+  def find_tag
+    @tag = ActsAsTaggableOn::Tag.find params[:id]
+  rescue ActiveRecord::RecordNotFound
+    render_404
+  end
+end

data/app/controllers/issue_tags_controller.rb

@@ -0,0 +1,48 @@
+class IssueTagsController < ApplicationController
+  before_action :find_issues, only: %i[edit update]
+
+  def edit
+    return unless AdditionalTags.setting?(:active_issue_tags) &&
+                  User.current.allowed_to?(:edit_issue_tags, @projects.first)
+
+    @issue_ids = params[:ids]
+    @is_bulk_editing = @issue_ids.size > 1
+    @issue_tags = if @is_bulk_editing
+                    issues = @issues.map(&:tag_list)
+                    issues.flatten!
+                    issues.uniq
+                  else
+                    @issues.first.tag_list
+                  end
+
+    @issue_tags.sort!
+    @most_used_tags = Issue.available_tags.most_used 10
+  end
+
+  def update
+    if AdditionalTags.setting?(:active_issue_tags) &&
+       User.current.allowed_to?(:edit_issue_tags, @projects.first)
+      tags = params[:issue] && params[:issue][:tag_list] ? params[:issue][:tag_list].reject(&:empty?) : []
+
+      unless User.current.allowed_to?(:create_issue_tags, @projects.first) || Issue.allowed_tags?(tags)
+        flash[:error] = t(:notice_failed_to_add_tags)
+        return
+      end
+
+      Issue.transaction do
+        @issues.each do |issue|
+          issue.tag_list = tags
+          issue.save!
+        end
+      end
+      flash[:notice] = t(:notice_tags_added)
+    else
+      flash[:error] = t(:notice_failed_to_add_tags)
+    end
+  rescue StandardError => e
+    Rails.logger.warn "Failed to add tags: #{e.inspect}"
+    flash[:error] = t(:notice_failed_to_add_tags)
+  ensure
+    redirect_to_referer_or { render text: 'Tags updated.', layout: true }
+  end
+end

data/app/helpers/additional_tags_helper.rb

@@ -0,0 +1,197 @@
+require 'digest/md5'
+
+module AdditionalTagsHelper
+  include ActsAsTaggableOn::TagsHelper
+
+  def manageable_tags
+    AdditionalTags::Tags.sort_tag_list ActsAsTaggableOn::Tag.where({})
+  end
+
+  def manageable_tag_columns
+    return @manageable_tag_columns if defined? @manageable_tag_columns
+
+    columns = {}
+
+    if AdditionalTags.setting?(:active_issue_tags)
+      columns[:issue] = { label: l(:label_issue_plural),
+                          tag_controller: :issues,
+                          counts: Issue.available_tags.map { |tag| [tag.id, tag.count] }.to_h }
+    end
+
+    if AdditionalTags.setting?(:active_wiki_tags)
+      columns[:wiki] = { label: l(:label_wiki),
+                         counts: WikiPage.available_tags.map { |tag| [tag.id, tag.count] }.to_h }
+    end
+
+    call_hook :helper_additional_manageable_tag_columns, columns: columns
+
+    @manageable_tag_columns = columns
+  end
+
+  def manageable_tag_column_values(tag)
+    columns = []
+    manageable_tag_columns.each do |_column, column_values|
+      cnt = column_values[:counts][tag.id]
+      cnt = 0 if cnt.blank?
+
+      columns << if cnt.positive? && column_values[:tag_controller]
+                   link_to cnt, tag_url(tag.name, tag_controller: column_values[:tag_controller])
+                 else
+                   cnt
+                 end
+    end
+    columns
+  end
+
+  def render_tags_list(tags, options = {})
+    return if tags.blank?
+
+    style = options.delete(:style)
+    tags = tags.all.to_a if tags.respond_to?(:all)
+
+    case "#{AdditionalTags.setting :tags_sort_by}:#{AdditionalTags.setting :tags_sort_order}"
+    when 'name:desc'
+      tags = AdditionalTags::Tags.sort_tag_list(tags).reverse
+    when 'count:asc'
+      tags.sort! { |a, b| a.count <=> b.count }
+    when 'count:desc'
+      tags.sort! { |a, b| b.count <=> a.count }
+    else
+      tags = AdditionalTags::Tags.sort_tag_list tags
+    end
+
+    case style
+    when :list
+      list_el = 'ul'
+      item_el = 'li'
+    when :simple_cloud, :cloud
+      list_el = 'div'
+      item_el = 'span'
+    else
+      raise 'Unknown list style'
+    end
+
+    content = ''.html_safe
+    if style == :list && AdditionalTags.setting(:tags_sort_by) == 'name'
+      tags.group_by { |tag| tag.name.downcase.first }.each do |letter, grouped_tags|
+        content << content_tag(item_el, letter.upcase, class: 'letter')
+        add_tags style, grouped_tags, content, item_el, options
+      end
+    else
+      add_tags style, tags, content, item_el, options
+    end
+
+    content_tag(list_el, content, class: 'tags-cloud', style: (style == :simple_cloud ? 'text-align: left;' : ''))
+  end
+
+  def additional_tag_link(tag_object, options = {})
+    tag_name = []
+    tag_name << tag_object.name
+
+    options[:project] = @project if options[:project].blank? && @project.present?
+
+    use_colors = AdditionalTags.setting?(:use_colors)
+    if use_colors
+      tag_bg_color = additional_tag_color tag_object.name
+      tag_fg_color = additional_tag_fg_color tag_bg_color
+      tag_style = "background-color: #{tag_bg_color}; color: #{tag_fg_color}"
+    end
+
+    tag_name << tag.span("(#{tag_object.count})", class: 'tag-count') if options[:show_count]
+
+    content = if options[:link]
+                link_to safe_join(tag_name),
+                        options[:link],
+                        style: tag_style
+              elsif options[:link_wiki_tag]
+                link_to safe_join(tag_name),
+                        project_wiki_index_path(options[:project], tag: tag_object.name),
+                        style: tag_style
+              else
+                link_to safe_join(tag_name),
+                        tag_url(tag_object.name, options),
+                        style: tag_style
+              end
+
+    style = if use_colors
+              { class: 'additional-tag-label-color', style: tag_style }
+            else
+              { class: 'tag-label' }
+            end
+
+    tag.span content, style
+  end
+
+  def additional_tag_color(tag_name)
+    "##{Digest::MD5.hexdigest(tag_name)[0..5]}"
+  end
+
+  def additional_tag_fg_color(bg_color)
+    # calculate contrast text color according to YIQ method
+    # https://24ways.org/2010/calculating-color-contrast/
+    # https://stackoverflow.com/questions/3942878/how-to-decide-font-color-in-white-or-black-depending-on-background-color
+    r = bg_color[1..2].hex
+    g = bg_color[3..4].hex
+    b = bg_color[5..6].hex
+    (r * 299 + g * 587 + b * 114) >= 128_000 ? 'black' : 'white'
+  end
+
+  # plain list of tags
+  def additional_plain_tag_list(tags, sep = ' ')
+    s = if tags.blank?
+          ['']
+        else
+          tags.map(&:name)
+        end
+    s.join sep
+  end
+
+  def additional_tag_links(tag_list, options = {})
+    return if tag_list.blank?
+
+    sep = if options[:use_colors].nil? || options[:use_colors]
+            ' '
+          else
+            ', '
+          end
+
+    unsorted = options.delete(:unsorted)
+    tag_list = AdditionalTags::Tags.sort_tag_list(tag_list) unless unsorted
+
+    safe_join tag_list.map { |tag| additional_tag_link tag, options }, sep
+  end
+
+  private
+
+  def tag_url(tag_name, options = {})
+    action = options[:tag_action].presence || (controller_name == 'hrm_user_resources' ? 'show' : 'index')
+
+    fields = [:tags]
+    values = { tags: [tag_name] }
+    operators = { tags: '=' }
+
+    if options[:filter].present?
+      field = options[:filter][:field]
+      fields << field
+      operators[field] = options[:filter][:operator]
+      values[field] = options[:filter][:value] if options[:filter].key?(:value)
+    end
+
+    { controller: options[:tag_controller].presence || controller_name,
+      action: action,
+      set_filter: 1,
+      project_id: options[:project],
+      f: fields,
+      v: values,
+      op: operators }
+  end
+
+  def add_tags(style, tags, content, item_el, options)
+    tag_cloud tags, (1..8).to_a do |tag, weight|
+      content << ' '.html_safe + content_tag(item_el,
+                                             additional_tag_link(tag, options),
+                                             class: "tag-nube-#{weight}",
+                                             style: (style == :simple_cloud ? 'font-size: 1em;' : '')) + ' '.html_safe
+    end
+  end
+end

data/app/helpers/additional_tags_issues_helper.rb

@@ -0,0 +1,43 @@
+module AdditionalTagsIssuesHelper
+  # Hacked render_api_custom_values to add plugin values to issue api
+  def render_api_custom_values(custom_values, api)
+    rc = super
+
+    if @issue.present? &&
+       (defined?(controller_name) && controller_name == 'issues' && action_name == 'show' || !defined?(controller_name)) &&
+       User.current.allowed_to?(:view_issues, @project)
+
+      api.array :tags do
+        @issue.tags.each do |tag|
+          api.tag(id: tag.id, name: tag.name)
+        end
+      end
+    end
+
+    rc
+  end
+
+  def sidebar_tags
+    # we do not want tags on issue import
+    return if controller_name == 'imports'
+
+    unless @sidebar_tags
+      @sidebar_tags = []
+      if AdditionalTags.show_sidebar_tags?
+        @sidebar_tags = Issue.available_tags project: @project,
+                                             open_issues_only: AdditionalTags.setting?(:open_issues_only)
+      end
+    end
+    @sidebar_tags.to_a
+  end
+
+  def render_sidebar_tags
+    options = { show_count: AdditionalTags.setting?(:show_with_count),
+                filter: AdditionalTags.setting?(:open_issues_only) ? { field: :status_id, operator: 'o' } : nil,
+                style: AdditionalTags.setting(:tags_sidebar).to_sym,
+                project: @project }
+
+    options[:tag_action] = 'show' if %w[gantts calendars].include? controller_name
+    render_tags_list sidebar_tags, options
+  end
+end

data/app/helpers/additional_tags_wiki_helper.rb

@@ -0,0 +1,17 @@
+module AdditionalTagsWikiHelper
+  def sidebar_tags
+    unless @sidebar_tags
+      @sidebar_tags = []
+      @sidebar_tags = WikiPage.available_tags(project: @project) if AdditionalTags.show_sidebar_tags?
+    end
+    @sidebar_tags
+  end
+
+  def render_sidebar_tags
+    render_tags_list sidebar_tags,
+                     show_count: AdditionalTags.setting?(:show_with_count),
+                     style: AdditionalTags.setting(:tags_sidebar).to_sym,
+                     link_wiki_tag: true,
+                     project: @project
+  end
+end

data/app/jobs/additional_tags_job.rb

@@ -0,0 +1,3 @@
+class AdditionalTagsJob < AdditionalsJob
+  queue_as :additional_tags
+end

data/app/jobs/additional_tags_remove_unused_tag_job.rb

@@ -0,0 +1,5 @@
+class AdditionalTagsRemoveUnusedTagJob < AdditionalTagsJob
+  def perform
+    AdditionalTags::Tags.remove_unused_tags
+  end
+end

data/app/models/migrate_tag.rb

@@ -0,0 +1,4 @@
+class MigrateTag < ActiveRecord::Base
+  self.table_name = 'tags'
+  has_many :migrate_taggings, dependent: :destroy, foreign_key: :tag_id, inverse_of: :migrate_tag
+end