additional_tags 1.0.0

data/lib/additional_tags/patches/dashboards_controller_patch.rb

@@ -0,0 +1,11 @@
+module AdditionalTags
+  module Patches
+    module DashboardsControllerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        helper :additional_tags
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/gantts_controller_patch.rb

@@ -0,0 +1,14 @@
+module AdditionalTags
+  module Patches
+    module GanttsControllerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        helper :additional_tags
+        helper :additional_tags_issues
+
+        include AdditionalTagsHelper
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/imports_controller_patch.rb

@@ -0,0 +1,12 @@
+module AdditionalTags
+  module Patches
+    module ImportsControllerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        helper :additional_tags
+        helper :additional_tags_issues
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/issue_patch.rb

@@ -0,0 +1,95 @@
+module AdditionalTags
+  module Patches
+    module IssuePatch
+      extend ActiveSupport::Concern
+
+      included do
+        include InstanceMethods
+        acts_as_ordered_taggable
+
+        before_save :prepare_save_tag_change
+        before_save :sort_tag_list
+
+        alias_method :safe_attributes_without_tags=, :safe_attributes=
+        alias_method :safe_attributes=, :safe_attributes_with_tags=
+
+        alias_method :copy_from_without_tags, :copy_from
+        alias_method :copy_from, :copy_from_with_tags
+      end
+
+      class_methods do
+        def allowed_tags?(tags)
+          allowed_tags = available_tags.map(&:name)
+          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)
+        end
+
+        def available_tags(options = {})
+          options[:permission] = :view_issues
+          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
+        # tag_list_changed? is broken for after_save
+        # tag_list_changed? is not working here, too!
+        def prepare_save_tag_change
+          return unless defined?(tag_list) && defined?(tag_list_was) && !tag_list_was.nil?
+
+          @prepare_save_tag_change ||= tag_list != tag_list_was
+        end
+
+        def safe_attributes_with_tags=(attrs, user = User.current)
+          if attrs && attrs[:tag_list]
+            tags = attrs.delete :tag_list
+            tags = Array(tags).reject(&:empty?)
+
+            if user.allowed_to?(:create_issue_tags, project) ||
+               user.allowed_to?(:edit_issue_tags, project) && Issue.allowed_tags?(tags)
+              attrs[:tag_list] = tags
+              self.tag_list = tags
+            end
+          end
+
+          send 'safe_attributes_without_tags=', attrs, user
+        end
+
+        def copy_from_with_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
+
+        private
+
+        def sort_tag_list
+          tags = tag_list.reject(&:empty?)
+          return unless tags.present? && tag_list_changed?
+
+          self.tag_list = AdditionalTags::Tags.sort_tags tags
+        end
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/issue_query_patch.rb

@@ -0,0 +1,55 @@
+module AdditionalTags
+  module Patches
+    module IssueQueryPatch
+      extend ActiveSupport::Concern
+
+      included do
+        include AdditionalsQuery
+        include InstanceMethods
+
+        alias_method :initialize_available_filters_without_tags, :initialize_available_filters
+        alias_method :initialize_available_filters, :initialize_available_filters_with_tags
+
+        alias_method :available_columns_without_tags, :available_columns
+        alias_method :available_columns, :available_columns_with_tags
+
+        alias_method :build_from_params_without_tags, :build_from_params
+        alias_method :build_from_params, :build_from_params_with_tags
+      end
+
+      module InstanceMethods
+        def initialize_available_filters_with_tags
+          initialize_available_filters_without_tags
+
+          initialize_tags_filter if !available_filters.key?('tags') &&
+                                    AdditionalTags.setting?(:active_issue_tags) &&
+                                    User.current.allowed_to?(:view_issue_tags, project, global: true)
+        end
+
+        def available_columns_with_tags
+          if @available_columns.nil?
+            @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)
+            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
+end

data/lib/additional_tags/patches/issues_controller_patch.rb

@@ -0,0 +1,14 @@
+module AdditionalTags
+  module Patches
+    module IssuesControllerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        helper :additional_tags
+        helper :additional_tags_issues
+
+        include AdditionalTagsHelper
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/journal_patch.rb

@@ -0,0 +1,18 @@
+module AdditionalTags
+  module Patches
+    module JournalPatch
+      extend ActiveSupport::Concern
+
+      included do
+        prepend InstanceOverwriteMethods
+      end
+
+      module InstanceOverwriteMethods
+        def visible_details(user = User.current)
+          details = super
+          details.reject { |x| x.prop_key == 'tag_list' && !user.allowed_to?(:view_issue_tags, project) }
+        end
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/my_controller_patch.rb

@@ -0,0 +1,14 @@
+module AdditionalTags
+  module Patches
+    module MyControllerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        helper :additional_tags
+        helper :additional_tags_issues
+
+        include AdditionalTagsHelper
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/queries_helper_patch.rb

@@ -0,0 +1,40 @@
+module AdditionalTags
+  module Patches
+    module QueriesHelperPatch
+      extend ActiveSupport::Concern
+
+      included do
+        include InstanceMethods
+
+        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
+            additional_tag_links column.value(item),
+                                 tag_controller: 'issues',
+                                 use_colors: AdditionalTags.setting?(:use_colors)
+          else
+            column_content_without_tags column, item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/reports_controller_patch.rb

@@ -0,0 +1,32 @@
+module AdditionalTags
+  module Patches
+    module ReportsControllerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        prepend InstanceOverwriteMethods
+      end
+
+      module InstanceOverwriteMethods
+        def issue_report
+          @tags = AdditionalTags::Tags.sort_tag_list Issue.available_tags(project_id: @project.id)
+          @issues_by_tags = Issue.by_tags @project, with_subprojects: Setting.display_subprojects_issues?
+          super
+        end
+
+        def issue_report_details
+          if params[:detail] == 'tag' &&
+             AdditionalTags.setting?(:active_issue_tags) &&
+             User.current.allowed_to?(:view_issue_tags, @project)
+            @field = 'tag_id'
+            @rows = AdditionalTags::Tags.sort_tag_list Issue.available_tags(project_id: @project.id)
+            @data = Issue.by_tags @project, with_subprojects: Setting.display_subprojects_issues?
+            @report_title = l :field_tags
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/settings_controller_patch.rb

@@ -0,0 +1,12 @@
+module AdditionalTags
+  module Patches
+    module SettingsControllerPatch
+      extend ActiveSupport::Concern
+
+      included do
+        helper :additional_tags
+        helper :additional_tags_issues
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/time_entry_patch.rb

@@ -0,0 +1,19 @@
+module AdditionalTags
+  module Patches
+    module TimeEntryPatch
+      extend ActiveSupport::Concern
+
+      included do
+        include InstanceMethods
+      end
+
+      module InstanceMethods
+        def issue_tags
+          return [] if issue.nil?
+
+          issue.tags
+        end
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/time_entry_query_patch.rb

@@ -0,0 +1,53 @@
+require_dependency 'time_entry_query'
+
+module AdditionalTags
+  module Patches
+    module TimeEntryQueryPatch
+      extend ActiveSupport::Concern
+
+      included do
+        include InstanceMethods
+
+        alias_method :initialize_available_filters_without_tags, :initialize_available_filters
+        alias_method :initialize_available_filters, :initialize_available_filters_with_tags
+
+        alias_method :available_columns_without_tags, :available_columns
+        alias_method :available_columns, :available_columns_with_tags
+      end
+
+      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,
+                               name: l('label_attribute_of_issue', name: l(:field_tags)),
+                               values: -> { available_issue_tags_values }
+        end
+
+        def available_columns_with_tags
+          if @available_columns.nil?
+            @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(:issue_tags)
+            end
+          else
+            available_columns_without_tags
+          end
+          @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)
+               .map { |c| [c.name, c.name] }
+        end
+      end
+    end
+  end
+end

data/lib/additional_tags/patches/time_report_patch.rb

@@ -0,0 +1,46 @@
+require_dependency 'query'
+
+module AdditionalTags
+  module Patches
+    module TimeReportPatch
+      extend ActiveSupport::Concern
+
+      included do
+        include InstanceMethods
+
+        alias_method :load_available_criteria_without_tags, :load_available_criteria
+        alias_method :load_available_criteria, :load_available_criteria_with_tags
+      end
+
+      module InstanceMethods
+        def load_available_criteria_with_tags
+          return @load_available_criteria_with_tags if @load_available_criteria_with_tags
+
+          @load_available_criteria_with_tags = load_available_criteria_without_tags
+          @load_available_criteria_with_tags['tags'] = { sql: "#{ActsAsTaggableOn.tags_table}.id",
+                                                         klass: ActsAsTaggableOn::Tag,
+                                                         joins: additional_tags_join,
+                                                         label: :field_tags }
+          @load_available_criteria_with_tags
+        end
+
+        private
+
+        def additional_tags_join
+          time_entry_table = Arel::Table.new TimeEntry.table_name
+          issues_table = Arel::Table.new Issue.table_name, as: :issues_time_entries
+          taggings_table = Arel::Table.new ActsAsTaggableOn.taggings_table
+          tags_table = Arel::Table.new ActsAsTaggableOn.tags_table
+
+          time_entry_table.join(issues_table)
+                          .on(issues_table[:id].eq(time_entry_table[:issue_id]))
+                          .join(taggings_table)
+                          .on(taggings_table[:taggable_id].eq(issues_table[:id]).and(taggings_table[:taggable_type].eq('Issue')))
+                          .join(tags_table)
+                          .on(tags_table[:id].eq(taggings_table[:tag_id]))
+                          .join_sources
+        end
+      end
+    end
+  end
+end