additional_tags 1.0.1 → 1.0.4

data/lib/additional_tags/patches/issue_patch.rb

@@ -1,15 +1,21 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module IssuePatch
       extend ActiveSupport::Concern
 
       included do
+        include Additionals::EntityMethodsGlobal
         include InstanceMethods
         acts_as_ordered_taggable
 
         before_save :prepare_save_tag_change
         before_save :sort_tag_list
 
+        after_commit :add_remove_unused_tags_job, on: %i[update destroy],
+                                                  if: proc { AdditionalTags.setting?(:active_issue_tags) }
+
         alias_method :safe_attributes_without_tags=, :safe_attributes=
         alias_method :safe_attributes=, :safe_attributes_with_tags=
 
@@ -20,25 +26,24 @@ module AdditionalTags
       class_methods do
         def allowed_tags?(tags)
           allowed_tags = available_tags.map(&:name)
-          tags.all? { |tag| allowed_tags.include?(tag) }
+          tags.all? { |tag| allowed_tags.include? tag }
         end
 
-        def by_tags(project, with_subprojects: false)
-          count_and_group_by(project: project, association: :tags, with_subprojects: with_subprojects)
+        def group_by_status_with_tags(project = nil)
+          visible(User.current, project: project).joins(:status)
+                                                 .joins(:tags)
+                                                 .group(:is_closed, 'tag_id')
+                                                 .count
         end
 
-        def available_tags(options = {})
+        def available_tags(**options)
           options[:permission] = :view_issues
-          tags = AdditionalTags::Tags.available_tags self, options
+          tags = AdditionalTags::Tags.available_tags self, **options
           return tags unless options[:open_issues_only]
 
           tags.joins("JOIN #{IssueStatus.table_name} ON #{IssueStatus.table_name}.id = #{table_name}.status_id")
               .where(issue_statuses: { is_closed: false })
         end
-
-        def remove_unused_tags!
-          AdditionalTagsRemoveUnusedTagJob.perform_later
-        end
       end
 
       module InstanceMethods
@@ -62,24 +67,18 @@ module AdditionalTags
             end
           end
 
-          send 'safe_attributes_without_tags=', attrs, user
+          send :safe_attributes_without_tags=, attrs, user
         end
 
+        # copy_from requires hash for Redmine - works with Ruby 3
+        # rubocop: disable Style/OptionHash
         def copy_from_with_tags(arg, options = {})
-          copy_from_without_tags(arg, options)
+          copy_from_without_tags arg, options
           issue = arg.is_a?(Issue) ? arg : Issue.visible.find(arg)
           self.tag_list = issue.tag_list
           self
         end
-
-        def tags_to_journal(old_tags, new_tags)
-          return if current_journal.blank? || old_tags == new_tags
-
-          current_journal.details << JournalDetail.new(property: 'attr',
-                                                       prop_key: 'tag_list',
-                                                       old_value: old_tags,
-                                                       value: new_tags)
-        end
+        # rubocop: enable Style/OptionHash
 
         private
 

data/lib/additional_tags/patches/issue_query_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module IssueQueryPatch
@@ -5,6 +7,7 @@ module AdditionalTags
 
       included do
         include AdditionalsQuery
+        prepend InstanceOverwriteMethods
         include InstanceMethods
 
         alias_method :initialize_available_filters_without_tags, :initialize_available_filters
@@ -12,9 +15,20 @@ module AdditionalTags
 
         alias_method :available_columns_without_tags, :available_columns
         alias_method :available_columns, :available_columns_with_tags
+      end
+
+      module InstanceOverwriteMethods
+        def build_from_params(params, defaults = {})
+          super
+
+          return self if params[:tag_id].blank?
 
-        alias_method :build_from_params_without_tags, :build_from_params
-        alias_method :build_from_params, :build_from_params_with_tags
+          add_filter 'tags',
+                     '=',
+                     [ActsAsTaggableOn::Tag.find_by(id: params[:tag_id]).try(:name)]
+
+          self
+        end
       end
 
       module InstanceMethods
@@ -31,24 +45,13 @@ module AdditionalTags
             @available_columns = available_columns_without_tags
 
             if AdditionalTags.setting?(:active_issue_tags) && User.current.allowed_to?(:view_issue_tags, project, global: true)
-              @available_columns << QueryColumn.new(:tags)
+              @available_columns << ::QueryTagsColumn.new
             end
           else
             available_columns_without_tags
           end
           @available_columns
         end
-
-        def build_from_params_with_tags(params, defaults = {})
-          build_from_params_without_tags params, defaults
-          return self if params[:tag_id].blank?
-
-          add_filter 'tags',
-                     '=',
-                     [ActsAsTaggableOn::Tag.find_by(id: params[:tag_id]).try(:name)]
-
-          self
-        end
       end
     end
   end

data/lib/additional_tags/patches/issues_controller_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module IssuesControllerPatch

data/lib/additional_tags/patches/journal_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module JournalPatch

data/lib/additional_tags/patches/my_controller_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module MyControllerPatch

data/lib/additional_tags/patches/queries_helper_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module QueriesHelperPatch
@@ -8,25 +10,11 @@ module AdditionalTags
 
         alias_method :column_content_without_tags, :column_content
         alias_method :column_content, :column_content_with_tags
-
-        alias_method :csv_content_without_tags, :csv_content
-        alias_method :csv_content, :csv_content_with_tags
       end
 
       module InstanceMethods
-        def csv_content_with_tags(column, item)
-          if item.is_a?(Issue) && column.name == :tags ||
-             item.is_a?(TimeEntry) && column.name == :issue_tags
-
-            additional_plain_tag_list column.value_object(item)
-          else
-            csv_content_without_tags column, item
-          end
-        end
-
         def column_content_with_tags(column, item)
-          if item.is_a?(Issue) && column.name == :tags ||
-             item.is_a?(TimeEntry) && column.name == :issue_tags
+          if column.name == :issue_tags || item.is_a?(Issue) && column.name == :tags
             additional_tag_links column.value(item),
                                  tag_controller: 'issues',
                                  use_colors: AdditionalTags.setting?(:use_colors)

data/lib/additional_tags/patches/query_patch.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module AdditionalTags
+  module Patches
+    module QueryPatch
+      extend ActiveSupport::Concern
+
+      included do
+        include InstanceMethods
+      end
+
+      module InstanceMethods
+        def sql_for_tags_field(field, _operator, values)
+          build_sql_for_tags_field klass: queried_class, operator: operator_for(field), values: values
+        end
+
+        def initialize_tags_filter(position: nil)
+          add_available_filter 'tags', order: position,
+                                       type: :list_optional,
+                                       values: -> { available_tag_values queried_class }
+        end
+
+        def initialize_issue_tags_filter
+          return unless AdditionalTags.setting?(:active_issue_tags) && User.current.allowed_to?(:view_issue_tags, project, global: true)
+
+          add_available_filter 'issue.tags',
+                               type: :list_optional,
+                               name: l('label_attribute_of_issue', name: l(:field_tags)),
+                               values: -> { available_tag_values Issue }
+        end
+
+        def available_tag_values(klass)
+          klass.available_tags(project: project)
+               .pluck(:name)
+               .map { |name| [name, name] }
+        end
+
+        def build_subquery_for_tags_field(klass:, operator:, values:, joined_table:, joined_field:,
+                                          source_field: 'id', target_field: 'issue_id')
+          quoted_joined_table = self.class.connection.quote_table_name joined_table
+          quoted_joined_field = self.class.connection.quote_column_name joined_field
+          quoted_source_field = self.class.connection.quote_column_name source_field
+          quoted_target_field = self.class.connection.quote_column_name target_field
+          subsql = ActsAsTaggableOn::Tagging.joins("INNER JOIN #{quoted_joined_table}" \
+                                                   " ON additional_taggings.taggable_id = #{quoted_joined_table}.#{quoted_target_field}")
+                                            .where(taggable_type: klass.name)
+                                            .where("#{self.class.connection.quote_table_name queried_table_name}.#{quoted_source_field} ="\
+                                                   " #{quoted_joined_table}.#{quoted_joined_field}")
+                                            .select(1)
+
+          if %w[= !].include? operator
+            ids_list = klass.tagged_with(values, any: true).pluck :id
+            subsql = subsql.where taggable_id: ids_list
+          end
+
+          if %w[= *].include? operator
+            " EXISTS(#{subsql.to_sql})"
+          else
+            " NOT EXISTS(#{subsql.to_sql})"
+          end
+        end
+
+        def build_sql_for_tags_field(klass:, operator:, values:)
+          compare = ['=', '*'].include?(operator) ? 'IN' : 'NOT IN'
+          case operator
+          when '=', '!'
+            ids_list = klass.tagged_with(values, any: true).pluck :id
+            if ids_list.present?
+              "(#{klass.table_name}.id #{compare} (#{ids_list.join ','}))"
+            elsif values.present? && operator == '='
+              # special case: filter with deleted tag
+              '(1=0)'
+            end
+          else
+            entries = ActsAsTaggableOn::Tagging.where taggable_type: klass.name
+            id_table = klass.table_name
+            "(#{id_table}.id #{compare} (#{entries.select(:taggable_id).to_sql}))"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/settings_controller_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module SettingsControllerPatch

data/lib/additional_tags/patches/time_entry_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module TimeEntryPatch

data/lib/additional_tags/patches/time_entry_query_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_dependency 'time_entry_query'
 
 module AdditionalTags
@@ -18,13 +20,7 @@ module AdditionalTags
       module InstanceMethods
         def initialize_available_filters_with_tags
           initialize_available_filters_without_tags
-
-          return unless AdditionalTags.setting?(:active_issue_tags) && User.current.allowed_to?(:view_issue_tags, project, global: true)
-
-          add_available_filter 'issue.tags',
-                               type: :list_optional,
-                               name: l('label_attribute_of_issue', name: l(:field_tags)),
-                               values: -> { available_issue_tags_values }
+          initialize_issue_tags_filter
         end
 
         def available_columns_with_tags
@@ -39,14 +35,8 @@ module AdditionalTags
           @available_columns
         end
 
-        def sql_for_issue_tags_field(_field, operator, value)
-          AdditionalTags.sql_for_tags_field Issue, operator, value
-        end
-
-        def available_issue_tags_values
-          Issue.available_tags(project: project)
-               .pluck(:name)
-               .map { |name| [name, name] }
+        def sql_for_issue_tags_field(_field, operator, values)
+          build_sql_for_tags_field klass: Issue, operator: operator, values: values
         end
       end
     end

data/lib/additional_tags/patches/time_report_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_dependency 'query'
 
 module AdditionalTags

data/lib/additional_tags/patches/timelog_controller_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module TimelogControllerPatch

data/lib/additional_tags/patches/wiki_controller_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module WikiControllerPatch
@@ -29,7 +31,7 @@ module AdditionalTags
           @tag = params[:tag]
           return super unless AdditionalTags.setting?(:active_wiki_tags) && @tag.present?
 
-          @pages = wiki_pages_with_tag @tag, @project
+          @pages = WikiPage.with_tags @tag, project: @project
 
           respond_to do |format|
             format.html do

data/lib/additional_tags/patches/wiki_page_patch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   module Patches
     module WikiPagePatch
@@ -20,10 +22,59 @@ module AdditionalTags
            "JOIN #{Project.table_name} ON wikis.project_id = #{Project.table_name}.id"]
         end
 
-        def available_tags(options = {})
+        def available_tags(**options)
           options[:project_join] = project_joins
           options[:permission] = :view_wiki_pages
-          AdditionalTags::Tags.available_tags self, options
+          AdditionalTags::Tags.available_tags self, **options
+        end
+
+        def with_tags_scope(project: nil, wiki: nil)
+          scope = if wiki
+                    wiki.pages
+                  else
+                    scope = WikiPage.joins wiki: :project
+                    scope = scope.where wikis: { project_id: project.id } if project
+                    scope
+                  end
+
+          scope = scope.visible User.current, project: project if scope.respond_to? :visible
+          scope
+        end
+
+        def with_tags(tag, project: nil, order: 'title_asc', max_entries: nil)
+          wiki = project&.wiki
+
+          scope = with_tags_scope wiki: wiki, project: project
+          scope = scope.limit max_entries if max_entries
+
+          tags = Array tag
+          tags.map!(&:strip)
+          tags.reject!(&:blank?)
+          return [] if tags.count.zero?
+
+          tags.map!(&:downcase)
+
+          scope = scope.where(id: tagged_with(tags, any: true).ids)
+                       .with_updated_on
+
+          return scope if order.nil?
+
+          sorted = order.split '_'
+          raise 'unsupported sort order' if sorted != 2 && %w[title date].exclude?(sorted.first)
+
+          order_dir = sorted.second == 'desc' ? 'DESC' : 'ASC'
+
+          case sorted.first
+          when 'date'
+            scope.joins(:content)
+                 .reorder("#{WikiContent.table_name}.updated_on #{order_dir}")
+          else
+            if wiki.nil?
+              scope.order "#{Project.table_name}.name, #{WikiPage.table_name}.title #{order_dir}"
+            else
+              scope.includes(:parent).order "#{WikiPage.table_name}.title #{order_dir}"
+            end
+          end
         end
       end
 
@@ -44,7 +95,7 @@ module AdditionalTags
             end
           end
 
-          send 'safe_attributes_without_tags=', attrs, user
+          send :safe_attributes_without_tags=, attrs, user
         end
 
         private

data/lib/additional_tags/plugin_version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AdditionalTags
+  module PluginVersion
+    VERSION = '1.0.4' unless defined? VERSION
+  end
+end

data/lib/additional_tags/tags.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 module AdditionalTags
   class Tags
     class << self
-      def available_tags(klass, options = {})
+      def available_tags(klass, **options)
         user = options[:user].presence || User.current
 
         scope = ActsAsTaggableOn::Tag.where({})
-        scope = scope.where("#{Project.table_name}.id = ?", options[:project]) if options[:project]
+        scope = scope.where "#{Project.table_name}.id = ?", options[:project] if options[:project]
         if options[:permission]
-          scope = scope.where(tag_access(options[:permission], user))
+          scope = scope.where tag_access(options[:permission], user)
         elsif options[:visible_condition]
-          scope = scope.where(klass.visible_condition(user))
+          scope = scope.where klass.visible_condition(user)
         end
-        scope = scope.where("LOWER(#{TAG_TABLE_NAME}.name) LIKE ?", "%#{options[:name_like].downcase}%") if options[:name_like]
-        scope = scope.where("#{TAG_TABLE_NAME}.name=?", options[:name]) if options[:name]
-        scope = scope.where("#{TAGGING_TABLE_NAME}.taggable_id!=?", options[:exclude_id]) if options[:exclude_id]
-        scope = scope.where(options[:where_field] => options[:where_value]) if options[:where_field].present? && options[:where_value]
+        scope = scope.where "LOWER(#{TAG_TABLE_NAME}.name) LIKE ?", "%#{options[:name_like].downcase}%" if options[:name_like]
+        scope = scope.where "#{TAG_TABLE_NAME}.name=?", options[:name] if options[:name]
+        scope = scope.where "#{TAGGING_TABLE_NAME}.taggable_id!=?", options[:exclude_id] if options[:exclude_id]
+        scope = scope.where options[:where_field] => options[:where_value] if options[:where_field].present? && options[:where_value]
 
         columns = ["#{TAG_TABLE_NAME}.id",
                    "#{TAG_TABLE_NAME}.name",
@@ -24,14 +26,14 @@ module AdditionalTags
         columns << "MIN(#{TAGGING_TABLE_NAME}.created_at) AS last_created" if options[:sort_by] == 'last_created'
 
         scope.select(columns.join(', '))
-             .joins(tag_for_joins(klass, options))
+             .joins(tag_for_joins(klass, **options.slice(:project_join, :project, :without_projects)))
              .group("#{TAG_TABLE_NAME}.id, #{TAG_TABLE_NAME}.name, #{TAG_TABLE_NAME}.taggings_count").having('COUNT(*) > 0')
              .order(build_order_sql(options[:sort_by], options[:order]))
       end
 
-      def all_type_tags(klass, options = {})
-        ActsAsTaggableOn::Tag.where({})
-                             .joins(tag_for_joins(klass, options))
+      def all_type_tags(klass, without_projects: false)
+        ActsAsTaggableOn::Tag.all
+                             .joins(tag_for_joins(klass, without_projects: without_projects))
                              .distinct
                              .order("#{TAG_TABLE_NAME}.name")
       end
@@ -61,8 +63,9 @@ module AdditionalTags
           # remove old (merged) tags
           tags_to_merge.reject { |t| t.id == tag.id }.each(&:destroy)
           # remove duplicate taggings
-          dup_scope = ActsAsTaggableOn::Tagging.where(tag_id: tag.id)
-          valid_ids = dup_scope.group(:tag_id, :taggable_id, :taggable_type, :tagger_id, :tagger_type, :context).pluck(Arel.sql('MIN(id)'))
+          dup_scope = ActsAsTaggableOn::Tagging.where tag_id: tag.id
+          valid_ids = dup_scope.group(:tag_id, :taggable_id, :taggable_type, :tagger_id, :tagger_type, :context)
+                               .pluck(Arel.sql('MIN(id)'))
           dup_scope.where.not(id: valid_ids).destroy_all if valid_ids.any?
           # recalc count for new tag
           ActsAsTaggableOn::Tag.reset_counters tag.id, :taggings
@@ -83,8 +86,65 @@ module AdditionalTags
         end
       end
 
+      def build_relation_tags(entries)
+        entries = Array entries
+        return [] if entries.none?
+
+        tags = entries.map(&:tags)
+        tags.flatten!
+
+        tags.uniq
+      end
+
+      def entity_group_by(scope:, tags:, statuses: nil, sub_groups: nil, group_id_is_bool: false)
+        counts = {}
+        tags.each do |tag|
+          values = { tag: tag, total: 0, total_sub_groups: 0, groups: [] }
+
+          if statuses
+            statuses.each do |status|
+              group_id = status.first
+              group = status.second
+              values[group] = status_for_tag_value scope: scope,
+                                                   tag_id: tag.id,
+                                                   group_id: group_id,
+                                                   group_id_is_bool: group_id_is_bool
+              values[:groups] << { id: group_id, group: group, count: values[group] }
+              values[:total] += values[group]
+              values[:total_sub_groups] += values[group] if sub_groups&.include? group_id
+            end
+          else
+            values[:total] += status_for_tag_value scope: scope, tag_id: tag.id
+          end
+
+          values[:total_without_sub_groups] = values[:total] - values[:total_sub_groups]
+
+          counts[tag.name] = values
+        end
+
+        counts
+      end
+
       private
 
+      def status_for_tag_value(scope:, tag_id:, group_id: nil, group_id_is_bool: false)
+        value = if group_id_is_bool || group_id
+                  if group_id_is_bool
+                    if group_id
+                      scope[[1, tag_id]] || scope[[true, tag_id]]
+                    else
+                      scope[[0, tag_id]] || scope[[false, tag_id]]
+                    end
+                  else
+                    scope[[group_id, tag_id]]
+                  end
+                else
+                  scope[tag_id]
+                end
+
+        value || 0
+      end
+
       def build_order_sql(sort_by, order)
         order = order.present? && order == 'DESC' ? 'DESC' : 'ASC'
 
@@ -100,16 +160,16 @@ module AdditionalTags
         Arel.sql sql
       end
 
-      def tag_for_joins(klass, options = {})
+      def tag_for_joins(klass, project_join: nil, project: nil, without_projects: false)
         table_name = klass.table_name
 
         joins = ["JOIN #{TAGGING_TABLE_NAME} ON #{TAGGING_TABLE_NAME}.tag_id = #{TAG_TABLE_NAME}.id"]
         joins << "JOIN #{table_name} " \
                  "ON #{table_name}.id = #{TAGGING_TABLE_NAME}.taggable_id AND #{TAGGING_TABLE_NAME}.taggable_type = '#{klass}'"
 
-        if options[:project_join]
-          joins << options[:project_join]
-        elsif options[:project] || !options[:without_projects]
+        if project_join
+          joins << project_join
+        elsif project || !without_projects
           joins << "JOIN #{Project.table_name} ON #{table_name}.project_id = #{Project.table_name}.id"
         end