additional_tags 1.0.5 → 1.0.7

data/lib/additional_tags/patches/issue_patch.rb

@@ -13,6 +13,8 @@ module AdditionalTags
         before_save :prepare_save_tag_change
         before_save :sort_tag_list
 
+        validate :validate_tags, if: proc { AdditionalTags.setting?(:active_issue_tags) }
+
         after_commit :add_remove_unused_tags_job, on: %i[update destroy],
                                                   if: proc { AdditionalTags.setting?(:active_issue_tags) }
 
@@ -29,21 +31,58 @@ module AdditionalTags
           tags.all? { |tag| allowed_tags.include? tag }
         end
 
-        def group_by_status_with_tags(project = nil)
-          visible(User.current, project: project).joins(:status)
-                                                 .joins(:tags)
-                                                 .group(:is_closed, 'tag_id')
-                                                 .count
+        def group_by_status_with_tags(project = nil, user = User.current)
+          scope = if project && Setting.display_subprojects_issues?
+                    visible(user).where(AdditionalTags::Tags.subproject_sql(project))
+                  else
+                    visible user, project: project
+                  end
+
+          scope.joins(:status)
+               .joins(:tags)
+               .group(:is_closed, 'tag_id')
+               .count
         end
 
         def available_tags(**options)
-          options[:permission] = :view_issues
+          options[:permission] ||= :view_issue_tags
           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 common_tag_list_from_issues(ids)
+          common_tags = ActsAsTaggableOn::Tag.joins(:taggings)
+                                             .select(
+                                               "#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.id",
+                                               "#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.name"
+                                             )
+                                             .where(taggings: { taggable_type: 'Issue', taggable_id: ids })
+                                             .group(
+                                               "#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.id",
+                                               "#{ActiveRecord::Base.connection.quote_table_name ActsAsTaggableOn.tags_table}.name"
+                                             )
+                                             .having('count(*) = ?', ids.count).to_a
+
+          ActsAsTaggableOn::TagList.new common_tags
+        end
+
+        def load_visible_tags(issues, user = User.current)
+          return if issues.blank?
+
+          available_projects = Project.where(AdditionalTags::Tags.visible_condition(user)).ids
+
+          issues.each do |issue|
+            tags = if available_projects.include? issue.project_id
+                     issue.tags
+                   else
+                     []
+                   end
+            issue.instance_variable_set :@visible_tags, tags
+          end
+        end
       end
 
       module InstanceMethods
@@ -62,7 +101,7 @@ module AdditionalTags
           tags = attrs.delete :tag_list
           tags = Array(tags).reject(&:empty?)
 
-          Additionals.debug "tags: #{tags.inspect} - project: #{project&.id} - access: #{user.allowed_to? :create_issue_tags, project}"
+          # Additionals.debug "tags: #{tags.inspect} - project: #{project&.id} - access: #{user.allowed_to? :create_issue_tags, project}"
 
           if user.allowed_to?(:create_issue_tags, project) ||
              user.allowed_to?(:edit_issue_tags, project) && Issue.allowed_tags?(tags)
@@ -88,6 +127,13 @@ module AdditionalTags
 
           self.tag_list = AdditionalTags::Tags.sort_tags tags
         end
+
+        def validate_tags
+          return if !User.current.allowed_to?(:create_issue_tags, project) &&
+                    !(User.current.allowed_to?(:edit_issue_tags, project) && Issue.allowed_tags?(tags))
+
+          errors.add :tag_list, :invalid_mutually_exclusive_tags unless AdditionalTag.valid_mutually_exclusive_tag tag_list
+        end
       end
     end
   end

data/lib/additional_tags/patches/issue_query_patch.rb

@@ -15,6 +15,9 @@ module AdditionalTags
 
         alias_method :available_columns_without_tags, :available_columns
         alias_method :available_columns, :available_columns_with_tags
+
+        alias_method :issues_without_tags, :issues
+        alias_method :issues, :issues_with_tags
       end
 
       module InstanceOverwriteMethods
@@ -29,9 +32,24 @@ module AdditionalTags
 
           self
         end
+
+        def sql_for_tags_field(field, _operator, values)
+          build_sql_for_tags_field_with_permission klass: queried_class,
+                                                   operator: operator_for(field),
+                                                   values: values,
+                                                   permission: :view_issue_tags
+        end
       end
 
       module InstanceMethods
+        def issues_with_tags(**options)
+          issues = issues_without_tags(**options)
+          return issues unless has_column? :tags
+
+          Issue.load_visible_tags issues
+          issues
+        end
+
         def initialize_available_filters_with_tags
           initialize_available_filters_without_tags
 

data/lib/additional_tags/patches/queries_helper_patch.rb

@@ -15,9 +15,7 @@ module AdditionalTags
       module InstanceMethods
         def column_content_with_tags(column, item)
           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)
+            additional_tag_links item.instance_variable_get(:@visible_tags), tag_controller: 'issues'
           else
             column_content_without_tags column, item
           end

data/lib/additional_tags/patches/query_patch.rb

@@ -11,7 +11,9 @@ module AdditionalTags
 
       module InstanceMethods
         def sql_for_tags_field(field, _operator, values)
-          build_sql_for_tags_field klass: queried_class, operator: operator_for(field), values: values
+          build_sql_for_tags_field klass: queried_class,
+                                   operator: operator_for(field),
+                                   values: values
         end
 
         def initialize_tags_filter(position: nil)
@@ -44,7 +46,7 @@ module AdditionalTags
           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} ="\
+                                            .where("#{self.class.connection.quote_table_name queried_table_name}.#{quoted_source_field} =" \
                                                    " #{quoted_joined_table}.#{quoted_joined_field}")
                                             .select(1)
 
@@ -60,6 +62,25 @@ module AdditionalTags
           end
         end
 
+        # NOTE: should be used, if tags required permission check
+        def build_sql_for_tags_field_with_permission(klass:, operator:, values:, permission:)
+          compare = ['=', '*'].include?(operator) ? 'in' : 'not_in'
+          case operator
+          when '=', '!'
+            ids_list = klass.tagged_with(values, any: true).ids
+            # special case: filter with deleted tag
+            return '(1=0)' if ids_list.blank? && values.present? && operator == '='
+          else
+            allowed_projects = Project.where(Project.allowed_to_condition(User.current, permission))
+                                      .select(:id)
+            ids_list = klass.tagged_with(klass.available_tags(skip_pre_condition: true), any: true)
+                            .where(project_id: allowed_projects).ids
+          end
+
+          "(#{klass.arel_table[:id].send(compare, ids_list).to_sql})"
+        end
+
+        # NOTE: should be used, if tags do not require permission check
         def build_sql_for_tags_field(klass:, operator:, values:)
           compare = ['=', '*'].include?(operator) ? 'IN' : 'NOT IN'
           case operator

data/lib/additional_tags/patches/wiki_page_patch.rb

@@ -13,6 +13,7 @@ module AdditionalTags
         alias_method :safe_attributes_without_tags=, :safe_attributes=
         alias_method :safe_attributes=, :safe_attributes_with_tags=
 
+        validate :validate_tags
         before_save :sort_tag_list
       end
 
@@ -24,7 +25,7 @@ module AdditionalTags
 
         def available_tags(**options)
           options[:project_join] = project_joins
-          options[:permission] = :view_wiki_pages
+          options[:permission] ||= :view_wiki_pages
           AdditionalTags::Tags.available_tags self, **options
         end
 
@@ -41,10 +42,11 @@ module AdditionalTags
           scope
         end
 
-        def with_tags(tag, project: nil, order: 'title_asc', max_entries: nil)
+        def with_tags(tag, project: nil, order: 'title_asc', max_entries: nil, exclude_page: nil)
           wiki = project&.wiki
 
           scope = with_tags_scope wiki: wiki, project: project
+          scope = scope.where.not id: exclude_page.id if exclude_page
           scope = scope.limit max_entries if max_entries
 
           tags = Array tag
@@ -105,6 +107,10 @@ module AdditionalTags
 
           self.tag_list = AdditionalTags::Tags.sort_tags tag_list
         end
+
+        def validate_tags
+          errors.add :tag_list, :invalid_mutually_exclusive_tags unless AdditionalTag.valid_mutually_exclusive_tag tag_list
+        end
       end
     end
   end

data/lib/additional_tags/plugin_version.rb

@@ -2,6 +2,6 @@
 
 module AdditionalTags
   module PluginVersion
-    VERSION = '1.0.5' unless defined? VERSION
+    VERSION = '1.0.7' unless defined? VERSION
   end
 end

data/lib/additional_tags/tags.rb

@@ -3,13 +3,27 @@
 module AdditionalTags
   class Tags
     class << self
+      def visible_condition(user, **options)
+        permission = options[:permission] || :view_issue_tags
+        skip_pre_condition = options[:skip_pre_condition] || true
+
+        tag_access permission, user, skip_pre_condition: skip_pre_condition
+      end
+
       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]
+        if options[:project]
+          scope = if Setting.display_subprojects_issues?
+                    scope.where subproject_sql(options[:project])
+                  else
+                    scope.where projects: { id: options[:project] }
+                  end
+        end
+
         if options[:permission]
-          scope = scope.where tag_access(options[:permission], user)
+          scope = scope.where tag_access(options[:permission], user, skip_pre_condition: options[:skip_pre_condition])
         elsif options[:visible_condition]
           scope = scope.where klass.visible_condition(user)
         end
@@ -18,14 +32,7 @@ module AdditionalTags
         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",
-                   "#{TAG_TABLE_NAME}.taggings_count",
-                   "COUNT(DISTINCT #{TAGGING_TABLE_NAME}.taggable_id) AS count"]
-
-        columns << "MIN(#{TAGGING_TABLE_NAME}.created_at) AS last_created" if options[:sort_by] == 'last_created'
-
-        scope.select(columns.to_list)
+        scope.select(table_columns(options[:sort_by]))
              .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]))
@@ -49,8 +56,7 @@ module AdditionalTags
       end
 
       def remove_unused_tags
-        ActsAsTaggableOn::Tag.left_outer_joins(:taggings)
-                             .where(taggings: { id: nil })
+        ActsAsTaggableOn::Tag.where.missing(:taggings)
                              .each(&:destroy)
       end
 
@@ -126,8 +132,23 @@ module AdditionalTags
         counts
       end
 
+      def subproject_sql(project)
+        "#{Project.table_name}.lft >= #{project.lft} " \
+          "AND #{Project.table_name}.rgt <= #{project.rgt}"
+      end
+
       private
 
+      def table_columns(sort_by)
+        columns = ["#{TAG_TABLE_NAME}.id",
+                   "#{TAG_TABLE_NAME}.name",
+                   "#{TAG_TABLE_NAME}.taggings_count",
+                   "COUNT(DISTINCT #{TAGGING_TABLE_NAME}.taggable_id) AS count"]
+
+        columns << "MIN(#{TAGGING_TABLE_NAME}.created_at) AS last_created" if sort_by == 'last_created'
+        columns.to_list
+      end
+
       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
@@ -177,11 +198,11 @@ module AdditionalTags
         joins
       end
 
-      def tag_access(permission, user)
+      def tag_access(permission, user, skip_pre_condition: false)
         projects_allowed = if permission.nil?
                              Project.visible.ids
                            else
-                             Project.where(Project.allowed_to_condition(user, permission)).ids
+                             Project.where(Project.allowed_to_condition(user, permission, skip_pre_condition: skip_pre_condition)).ids
                            end
 
         if projects_allowed.present?

data/lib/additional_tags.rb

@@ -14,6 +14,11 @@ module AdditionalTags
       setting(:tags_sidebar).present? && setting(:tags_sidebar) != 'none'
     end
 
+    # color is used by default (if setting is missing, too)
+    def use_colors?
+      setting(:tags_color_theme).to_s != '0'
+    end
+
     private
 
     def setup

data/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {},
+  "devDependencies": {
+    "eslint": "^8.0.0",
+    "stylelint": "^14.0.0",
+    "stylelint-config-standard": "^29.0.0"
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: additional_tags
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.7
 platform: ruby
 authors:
 - AlphaNodes
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-25 00:00:00.000000000 Z
+date: 2022-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acts-as-taggable-on
@@ -92,6 +92,7 @@ files:
 - app/helpers/additional_tags_wiki_helper.rb
 - app/jobs/additional_tags_job.rb
 - app/jobs/additional_tags_remove_unused_tag_job.rb
+- app/models/additional_tag.rb
 - app/models/migrate_tag.rb
 - app/models/migrate_tagging.rb
 - app/models/query_tags_column.rb
@@ -143,6 +144,7 @@ files:
 - db/migrate/20201123093214_migrate_existing_tags.rb
 - doc/images/additional-tags-framework.png
 - doc/images/additional-tags.gif
+- doc/images/tag-overview.png
 - init.rb
 - lib/additional_tags.rb
 - lib/additional_tags/hooks/model_hook.rb
@@ -175,6 +177,7 @@ files:
 - lib/additional_tags/plugin_version.rb
 - lib/additional_tags/tags.rb
 - lib/tasks/additional_tags.rake
+- package.json
 homepage: https://github.com/alphanodes/additional_tags
 licenses:
 - GPL-2.0
@@ -195,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Redmine plugin for adding tag functionality