redmineup 1.0.2 → 1.1.13

data/doc/active-record-mixins.md

@@ -0,0 +1,156 @@
+# ActiveRecord mixins
+
+This page documents the model mixins provided by `redmineup`.
+
+## `up_acts_as_taggable`
+
+Adds polymorphic tagging support.
+
+### Migration
+
+```ruby
+class CreateTags < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_taggable_table
+  end
+end
+```
+
+Useful migration helpers:
+
+- `ActiveRecord::Base.create_taggable_table`
+- `ActiveRecord::Base.drop_taggable_table`
+- `ActiveRecord::Base.add_tags_column(:tags, name: :color, type: :integer, default: nil)`
+- `ActiveRecord::Base.remove_tags_columns(:tags, :color)`
+
+### Model
+
+```ruby
+class Product < ApplicationRecord
+  up_acts_as_taggable
+end
+```
+
+### Runtime API
+
+- `record.tag_list` / `record.tag_list = 'a, b'`
+- `record.save_tags` (called via callbacks)
+- `Model.available_tags(project: @project, limit: 30)`
+- `Model.tagged_with(['tag1', 'tag2'])`
+- `Model.find_related_tags('tag1')`
+
+## `up_acts_as_draftable`
+
+Adds draft save/restore workflow for unsaved or changed records.
+
+### Migration
+
+```ruby
+class CreateDrafts < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_drafts_table
+  end
+end
+```
+
+Helpers:
+
+- `ActiveRecord::Base.create_drafts_table`
+- `ActiveRecord::Base.drop_drafts_table`
+
+### Model
+
+```ruby
+class WikiPage < ApplicationRecord
+  up_acts_as_draftable parent: :wiki
+end
+```
+
+### Runtime API
+
+- `record.save_draft`
+- `record.update_draft(attrs)`
+- `Model.drafts(User.current)`
+- `Model.from_draft(draft_or_id)`
+
+## `up_acts_as_viewed`
+
+Tracks unique views by user (or IP) and total views.
+
+### Migration
+
+```ruby
+class CreateViewings < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_viewings_table
+  end
+end
+```
+
+Optional helpers for models with embedded counters:
+
+- `ActiveRecord::Base.generate_viewings_columns(table)`
+- `Model.add_viewings_columns`
+- `Model.remove_viewings_columns`
+- `ActiveRecord::Base.drop_viewings_table`
+
+### Model
+
+```ruby
+class Question < ApplicationRecord
+  up_acts_as_viewed
+end
+```
+
+### Runtime API
+
+- `record.view(request.remote_ip, User.current)`
+- `record.viewed?`
+- `record.view_count`
+- `record.viewed_by?(request.remote_ip, User.current)`
+
+## `up_acts_as_votable` and `up_acts_as_voter`
+
+Adds voting capabilities for content and users.
+
+### Migration
+
+```ruby
+class CreateVotes < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_votable_table
+  end
+end
+```
+
+Helpers:
+
+- `ActiveRecord::Base.create_votable_table`
+- `ActiveRecord::Base.drop_votable_table`
+
+### Models
+
+```ruby
+class Question < ApplicationRecord
+  up_acts_as_votable
+end
+
+class User < ApplicationRecord
+  up_acts_as_voter
+end
+```
+
+## `up_acts_as_priceable`
+
+Generates currency-aware `*_to_s` methods for price fields.
+
+### Model
+
+```ruby
+class Deal < ApplicationRecord
+  up_acts_as_priceable :amount, :tax_amount, :subtotal, :total
+end
+```
+
+This creates methods like `amount_to_s`, `tax_amount_to_s`, etc., backed by
+`Redmineup::MoneyHelper#object_price`.

data/doc/assets-money-and-utilities.md

@@ -0,0 +1,71 @@
+# Assets, money, and shared utilities
+
+## Asset helpers
+
+Provided by `Redmineup::ExternalAssetsHelper`:
+
+- `redmineup_assets`
+- `select2_assets` (alias for `redmineup_assets`)
+- `chartjs_assets`
+
+`redmineup_assets` includes:
+
+- `consumer.js`
+- `select2.js`
+- `select2_helpers.js`
+- `redmineup.css`
+
+The gem also hooks `view_layouts_base_html_head` and renders
+`redmineup/_additional_assets`, so shared assets can be included globally.
+Helpers are idempotent and safe to call from plugin views.
+
+## Money and currency
+
+### Settings API
+
+`Redmineup::Settings::Money` provides access to plugin-level money settings:
+
+- `default_currency`
+- `major_currencies`
+- `default_tax`
+- `tax_type`, `tax_exclusive?`
+- `thousands_delimiter`
+- `decimal_separator`
+- `disable_taxes?`
+
+### Formatting helpers
+
+`Redmineup::MoneyHelper` provides:
+
+- `price_to_currency(price, currency, options = {})`
+- `object_price(record, :price)`
+- `prices_collection_by_currency(hash, hide_zeros: true)`
+- `collection_for_currencies_select`
+- `all_currencies`
+
+`up_acts_as_priceable` uses these helpers to generate `*_to_s` methods on
+models.
+
+### Admin UI
+
+`Redmineup::Currency.add_admin_money_menu` registers a Redmine admin menu item
+that points to:
+
+- `redmineup_settings_path(:money)`
+
+## Misc shared helpers and patches
+
+- `Redmineup::CalendarsHelper#calendar_day_css_classes`
+- Liquid patch for numeric conversion in `Liquid::StandardFilters`
+- Liquid filters/drops under `lib/redmineup/liquid/**`
+- Compatibility and ActionCable patches loaded at gem boot
+
+## Version requirements in plugins
+
+Plugins typically guard compatibility in `init.rb`:
+
+```ruby
+requires_redmineup version_or_higher: '1.1.5'
+```
+
+Use this to fail fast when a plugin depends on newer helper or API behavior.

data/doc/tagging-and-select2.md

@@ -0,0 +1,108 @@
+# Tagging and Select2 helpers
+
+This page covers view helpers used by RedmineUP plugins for tag rendering,
+tag editing, and select2-backed filters.
+
+## Tag rendering helpers
+
+Provided by `Redmineup::TagsHelper`:
+
+- `tag_link(url, tag_name, options = {})`
+- `tag_links(tag_list, options = {}) { |tag| url }`
+- `tag_cloud(tags, classes) { |tag, css_class| ... }`
+- `tag_cloud_links(tags, key, options = {})`
+- `tag_separator`
+
+### Recommended pattern
+
+Define `*_tag_url` per plugin context:
+
+```ruby
+def contact_tag_url(tag_name, options = {})
+  {
+    controller: 'contacts',
+    action: 'index',
+    set_filter: 1,
+    fields: [:tags],
+    values: { tags: [tag_name] },
+    operators: { tags: '=' }
+  }.merge(options)
+end
+```
+
+Then render the cloud via convention:
+
+```erb
+<%= tag_cloud_links(Contact.available_tags(project: @project), :contact) %>
+```
+
+`tag_cloud_links(tags, :contact)` expects `contact_tag_url(name)` to be defined
+in the current view context.
+
+## Tag editors with Select2
+
+Provided by `Redmineup::FormTagHelper`:
+
+- `select2_tag(name, option_tags = nil, options = {})`
+- `select2(...)` (alias)
+- `tag_list_field_tag(name, value = [], options = {})`
+- `transform_to_select2(type, options = {})`
+
+`ActionView::Helpers::FormBuilder` is extended with:
+
+- `f.tag_list_field(:tag_list, **options)`
+
+### Example: form object API
+
+```erb
+<%= f.tag_list_field :tag_list, width: '95%' %>
+```
+
+### Example: standalone field API
+
+```erb
+<%= tag_list_field_tag 'product[tag_list]', @product.tag_list, taggable_type: 'Product' %>
+```
+
+### Example: query/filter select2 transform
+
+```erb
+<%= transform_to_select2 'product_tags',
+      url: auto_complete_taggable_tags_path(project_id: @project, taggable_type: 'Product') %>
+```
+
+## Tag autocomplete endpoint
+
+`redmineup` adds a shared route:
+
+- `GET /auto_completes/taggable_tags`
+
+Named route:
+
+- `auto_complete_taggable_tags_path`
+
+Typical params used by plugins:
+
+- `taggable_type`: model class name (`Contact`, `Person`, `Product`, `Issue`, `DriveEntry`)
+- `project_id`: optional project scope
+- `limit`: optional result size limit
+
+Response format:
+
+```json
+[
+  { "id": "important", "text": "important" },
+  { "id": "vip", "text": "vip" }
+]
+```
+
+## Real plugin usage
+
+Patterns above are used by:
+
+- `redmine_contacts` (`contact_tag_url`, `contact_tag_links`, `f.tag_list_field`)
+- `redmine_people` (`people_tag_url`, `tag_cloud_links`, bulk edit tag forms)
+- `redmine_products` (`product_tag_url`, `tag_list_field_tag`, select2 filters)
+- `redmine_questions` (`question_tag_url`, `tag_cloud_links`)
+- `redmine_drive` (`drive_entry_tag_url`, select2 tag filters)
+- `redmineup_tags` (issue tag forms with `tag_list_field_tag`)

data/lib/action_cable/connection/rup_connection.rb

@@ -0,0 +1,17 @@
+module ActionCable
+  module Connection
+    class RupConnection < ActionCable::Connection::Base
+      identified_by :current_user
+
+      def connect
+        self.current_user = find_verified_user
+      end
+
+      private
+
+      def find_verified_user
+        User.find_by(id: @request.session[:user_id]) || User.anonymous
+      end
+    end
+  end
+end

data/lib/action_cable/server/rup_configuration.rb

@@ -0,0 +1,17 @@
+module ActionCable
+  module Server
+    class RupConfiguration < ActionCable::Server::Configuration
+      def initialize(connection_klass: 'ActionCable::Connection::Base')
+        super()
+
+        @connection_class = -> { connection_klass.constantize }
+        @logger ||= ::Rails.logger
+        @disable_request_forgery_protection = true
+      end
+
+      def cable
+        @cable ||= ActionCable.server.config.cable || { 'adapter' => 'async' }.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/action_cable/server/rup_server.rb

@@ -0,0 +1,17 @@
+module ActionCable
+  module Server
+    class RupServer < ActionCable::Server::Base
+      attr_reader :config
+
+      def initialize(config: self.class.config)
+        @config = config
+        @mutex = Monitor.new
+        @remote_connections = @event_loop = @worker_pool = @pubsub = nil
+      end
+
+      def setup_heartbeat_timer
+        Rails.logger.info('Heartbeat timer disabled for RupServer')
+      end
+    end
+  end
+end

data/lib/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/lib/redmineup/acts_as_taggable/tag.rb

@@ -1,3 +1,5 @@
+require 'digest/md5'
+
 module Redmineup
   module ActsAsTaggable #:nodoc:
     class Tag < ActiveRecord::Base #:nodoc:
@@ -17,6 +19,10 @@ module Redmineup
         where("LOWER(name) LIKE LOWER(?)", name).first || create(:name => name)
       end
 
+      def self.color_from_name(str)
+        "##{Digest::MD5.hexdigest(str.to_s)[0..5]}"
+      end      
+
       def ==(object)
         super || (object.is_a?(Tag) && name == object.name)
       end
@@ -29,6 +35,18 @@ module Redmineup
         read_attribute(:count).to_i
       end
 
+      def color
+        if self.class.column_names.include?('color')
+          db_color = read_attribute(:color)
+          return ('#' + "%06x" % db_color) unless db_color.nil?
+        end
+        self.class.color_from_name(name)
+      end
+
+      def color=(color)
+        write_attribute(:color, color.sub(/\A#/, '').hex) unless color.blank?
+      end
+
       class << self
         # Calculate the tag counts for all tags.
         #  :start_at - Restrict the tags to those created after a certain time
@@ -66,9 +84,15 @@ module Redmineup
           having    = 'COUNT(*) > 0'
           having    = [having, at_least, at_most].compact.join(' AND ')
           group_by  = "#{Tag.table_name}.id, #{Tag.table_name}.name"
-          # group_by << " AND #{having}" unless having.blank?
+          group_by << ", #{Tag.table_name}.color" if column_names.include?('color')
+
+          select_condition = if self.column_names.include?('color')
+            "#{Tag.table_name}.id, #{Tag.table_name}.name, #{Tag.table_name}.color, COUNT(*) AS count"
+          else
+            "#{Tag.table_name}.id, #{Tag.table_name}.name, COUNT(*) AS count"
+          end
 
-          { :select     => "#{Tag.table_name}.id, #{Tag.table_name}.name, COUNT(*) AS count",
+          { :select     => select_condition,
             :joins      => joins.join(" "),
             :conditions => conditions,
             :group      => group_by,

data/lib/redmineup/acts_as_taggable/up_acts_as_taggable.rb

@@ -44,7 +44,7 @@ module Redmineup
 
         # Create the taggable tables
         # === Options hash:
-        # * <tt>:table_name</tt> - use a table name other than viewings
+        # * <tt>:table_name</tt> - use a table name other than tags
         # To be used during migration, but can also be used in other places
         def create_taggable_table(options = {})
           tag_name_table = options[:tags] || :tags
@@ -52,6 +52,7 @@ module Redmineup
           if !self.connection.table_exists?(tag_name_table)
             self.connection.create_table(tag_name_table) do |t|
               t.column :name, :string
+              t.column :color, :integer
             end
           end
 
@@ -64,6 +65,7 @@ module Redmineup
               # You should make sure that the column created is
               # long enough to store the required class names.
               t.column :taggable_type, :string
+              t.column :color, :integer, default: nil
 
               t.column :created_at, :datetime
             end
@@ -73,6 +75,43 @@ module Redmineup
           end
         end
 
+        # Create the needed column for up_acts_as_taggable.
+        # To be used during migration, but can also be used in other places.
+        #
+        # Options :name, :type, :default are required
+        #
+        # By default, a :color: column will be created
+        #
+        # E.g.: ActiveRecord::Base.add_tags_column(:tags, name: :color, type: :string, default: nil)
+        def add_tags_column(table_name = :tags, **options)
+          tag_column = options
+          tag_column.assert_valid_keys(:name, :type, :default)
+
+          raise ArgumentError, "Table `#{table_name}' not found" unless self.connection.table_exists?(table_name)
+
+          self.table_name = table_name
+          return if connection.column_exists?(table_name, tag_column[:name])
+
+          connection.add_column table_name, tag_column[:name], tag_column[:type], default: tag_column[:default]
+          reset_column_information
+        end
+
+        # Remove the up_acts_as_taggable specific columns
+        # To be used during migration, but can also be used in other places
+        #
+        # E.g.: ActiveRecord::Base.remove_tags_columns(:tags, :color, :color1)
+        def remove_tags_columns(table_name = :tags, *columns)
+          raise ArgumentError, "Table `#{table_name}' not found" unless self.connection.table_exists?(table_name)
+          return if columns.blank?
+
+          columns.each do |column|
+            if self.connection.column_exists?(table_name, column)
+              self.connection.remove_column table_name, column
+              self.reset_column_information
+            end
+          end
+        end
+
         def drop_taggable_table(options = {})
           tag_name_table = options[:tags] || :tags
           if self.connection.table_exists?(tag_name_table)
@@ -103,13 +142,14 @@ module Redmineup
             scope = scope.where("#{table_name}.project_id IN (%s)", projects.map(&:id).join(','))
           end
 
-          if options[:name_like]
+          if options[:name_like].present?
             scope = scope.where("LOWER(#{Tag.table_name}.name) LIKE LOWER(?)", "%#{options[:name_like]}%")
           end
 
           group_fields = ''
           group_fields << ", #{Tag.table_name}.created_at" if Tag.respond_to?(:created_at)
           group_fields << ", #{Tag.table_name}.updated_at" if Tag.respond_to?(:updated_at)
+          group_fields << ", #{Tag.table_name}.color" if Tag.column_names.include?('color')
 
           if base_class.respond_to?(:visible_condition)
             visible_condition = base_class.visible_condition(User.current)

data/lib/redmineup/acts_as_viewed/up_acts_as_viewed.rb

@@ -235,7 +235,7 @@ module Redmineup
               t.column :viewer_id,   :integer
               t.column :viewed_id,   :integer
               t.column :viewed_type, :string
-              t.column :ip, :string, :limit => '24'
+              t.column :ip, :string, :limit => '45'
               t.column :created_at, :datetime
             end
 

data/lib/redmineup/acts_as_votable/votable.rb

@@ -232,11 +232,8 @@ module Redmineup
           end
         end
         self.record_timestamps = false
-        if (::ActiveRecord::VERSION::MAJOR == 3) && (::ActiveRecord::VERSION::MINOR != 0)
-          self.assign_attributes(updates, :without_protection => true) && self.save if !updates.empty?
-        else
-          self.assign_attributes(updates) && self.save if !updates.empty?
-        end
+
+        self.update(updates) if !updates.empty?
       end
 
       # results

data/lib/redmineup/assets_manager.rb

@@ -2,7 +2,8 @@ module Redmineup
   class AssetsManager
     def self.install_assets
       return unless Gem.loaded_specs[GEM_NAME]
-      source = File.join(Gem.loaded_specs[GEM_NAME].full_gem_path, 'vendor', 'assets')
+
+      source = File.join(Gem.loaded_specs[GEM_NAME].full_gem_path, 'app', 'assets')
       destination = File.join(Dir.pwd, 'public', 'plugin_assets', GEM_NAME)
       return unless File.directory?(source)
 
@@ -39,5 +40,15 @@ module Redmineup
         end
       end
     end
+
+    def self.base_path
+      Gem.loaded_specs[GEM_NAME].full_gem_path
+    end
+
+    def self.assets_paths
+      return [] unless Gem.loaded_specs[GEM_NAME]
+
+      Dir[File.join(base_path, 'app', 'assets', '*')]
+    end
   end
 end

data/lib/redmineup/currency.rb

@@ -40,7 +40,9 @@ module Redmineup
         Redmine::MenuManager.map(:admin_menu).push(:redmineup_money,
                                                    { controller: 'redmineup', action: 'settings', id: 'money' },
                                                    caption: :label_redmineup_money,
-                                                   html: { class: 'icon icon-redminecrm-money' })
+                                                   html: { class: 'icon icon-redmineup-money' },
+                                                   icon: 'money',
+                                                   plugin: :redmineup)
 
       end
 

data/lib/redmineup/engine.rb

@@ -1,4 +1,14 @@
 module Redmineup
-   class Engine < Rails::Engine
-   end
+  class Engine < Rails::Engine
+    config.to_prepare do
+      next unless defined?(::Redmine::Plugin)
+
+      require 'auto_completes_controller'
+
+      require File.expand_path('../redmineup/patches/compatibility_patch', __dir__)
+      require File.expand_path('../redmineup/patches/auto_completes_controller_patch', __dir__)
+
+      require File.expand_path('../redmineup/hooks/views_layouts_hook', __dir__)
+    end
+  end
 end

data/lib/redmineup/helpers/calendars_helper.rb

@@ -0,0 +1,22 @@
+module Redmineup
+  module CalendarsHelper
+
+    def calendar_day_css_classes(calendar, day)
+      css = day.month==calendar.month ? +'even' : +'odd'
+      css << " today" if User.current.today == day
+      css << " nwday" if non_working_week_days.include?(day.cwday)
+      css
+    end
+
+    def non_working_week_days
+      @non_working_week_days ||= begin
+        days = Setting.non_working_week_days
+        if days.is_a?(Array) && days.size < 7
+          days.map(&:to_i)
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/redmineup/helpers/datetime_helper.rb

@@ -0,0 +1,23 @@
+module Redmineup
+  module DatetimeHelper
+    def convert_time_to_user_timezone(time)
+      if User.current.time_zone
+        time.in_time_zone(User.current.time_zone)
+      else
+        time.utc? ? time.localtime : time
+      end
+    end
+
+    def convert_time_to_utc(time = Time.now)
+      return Time.now.utc if time.blank?
+      return time.utc if time.respond_to?(:utc)
+
+      time_zone = User.current.time_zone
+      return Time.parse(time).utc unless time_zone
+
+      Time.use_zone(time_zone) do
+        Time.zone.parse(time).utc
+      end
+    end
+  end
+end

data/lib/redmineup/helpers/external_assets_helper.rb

@@ -2,19 +2,27 @@ module Redmineup
   module ExternalAssetsHelper
     include ActionView::Helpers::JavaScriptHelper
 
+    def redmineup_assets
+      return if @redmineup_assets_included
+
+      @redmineup_assets_included = true
+      javascript_include_tag('consumer', plugin: GEM_NAME) +
+        javascript_include_tag('select2', plugin: GEM_NAME) +
+        javascript_include_tag('select2_helpers', plugin: GEM_NAME) +
+        javascript_include_tag('jquery.colorPicker.min', plugin: GEM_NAME) +
+        stylesheet_link_tag('redmineup', plugin: GEM_NAME) +
+        javascript_tag("window.redmineupWorkerUrl = #{asset_path('consumer_worker.js', plugin: GEM_NAME).to_json};")
+    end
+
     def select2_assets
-      return if @select2_tag_included
-      @select2_tag_included = true
-      javascript_include_tag('select2', plugin: GEM_NAME) +
-        stylesheet_link_tag('select2', plugin: GEM_NAME) +
-        javascript_include_tag('select2_helpers', plugin: GEM_NAME)
+      redmineup_assets
     end
 
     def chartjs_assets
       return if @chartjs_tag_included
+
       @chartjs_tag_included = true
-      javascript_include_tag('Chart.bundle.min', plugin: GEM_NAME)
+      javascript_include_tag('chart.min', plugin: GEM_NAME)
     end
-
   end
 end