redmine_crm 0.0.23 → 0.0.43

data/lib/redmine_crm/liquid/filters/base.rb

@@ -0,0 +1,217 @@
+require 'uri'
+require 'rack'
+require 'json'
+require 'date'
+require 'liquid'
+
+module RedmineCrm
+  module Liquid
+    module Filters
+      module Base
+        include RedmineCrm::MoneyHelper
+
+        def textilize(input)
+          RedCloth3.new(input).to_html
+        end
+
+        def default(input, value)
+          input.blank? ? value : input
+        end
+
+        def underscore(input)
+          input.to_s.gsub(' ', '_').gsub('/', '_').underscore
+        end
+
+        def dasherize(input)
+          input.to_s.gsub(' ', '-').gsub('/', '-').dasherize
+        end
+
+        def shuffle(array)
+          array.to_a.shuffle
+        end
+
+        def random(input)
+          rand(input.to_i)
+        end
+
+        def md5(input)
+          Digest::MD5.hexdigest(input) unless input.blank?
+        end        
+
+        # example:
+        #   {{ "http:://www.example.com?key=hello world" | encode }}
+        #
+        #   => http%3A%3A%2F%2Fwww.example.com%3Fkey%3Dhello+world
+        def encode(input)
+          ::Rack::Utils.escape(input)
+        end
+
+        # example:
+        #   {{ today | plus_days: 2 }}
+        def plus_days(input, distanse)
+          return '' if input.nil?
+          days = distanse.to_i
+          input.to_date + days.days rescue 'Invalid date'
+        end
+
+        # example:
+        #   {{ today | date_range: '2015-12-12' }}
+        def date_range(input, distanse)
+          return '' if input.nil?
+          (input.to_date - distanse.to_date).to_i rescue 'Invalid date'
+        end
+
+        # example:
+        #   {{ now | utc }}
+        def utc(input)
+          return '' if input.nil?
+          input.to_time.utc rescue 'Invalid date'
+        end
+
+        def modulo(input, operand)
+          apply_operation(input, operand, :%)
+        end
+
+        def round(input, n = 0)
+          result = to_number(input).round(to_number(n))
+          result = result.to_f if result.is_a?(BigDecimal)
+          result = result.to_i if n == 0
+          result
+        end
+
+        def ceil(input)
+          to_number(input).ceil.to_i
+        end
+
+        def floor(input)
+          to_number(input).floor.to_i
+        end
+
+        def currency(input, currency_code = 'USD')
+          price_to_currency(input, currency_code, :converted => false)
+        end
+
+        def call_method(input, method_name)
+          if input.respond_to?(method_name)
+            input.method(method_name).call
+          end
+        end
+
+        def custom_field(input, field_name)
+          if input.respond_to?(:custom_field_values)
+            custom_value = input.custom_field_values.detect { |cfv| cfv.custom_field.name == field_name }
+            custom_value.custom_field.format.formatted_custom_value(nil, custom_value)
+          end
+        end
+
+        def custom_fields(input)
+          if input.respond_to?(:custom_field_values)
+            input.custom_field_values.map { |cfv| cfv.custom_field.name }
+          end
+        end
+
+        def attachment(input, file_name)
+          if input.respond_to?(:attachments)
+            if input.attachments.is_a?(Hash)
+              attachment = input.attachments[file_name]
+            else
+              attachment = input.attachments.detect{|a| a.file_name == file_name}
+            end
+            AttachmentDrop.new attachment if attachment
+          end
+        end
+
+        protected
+
+        # Convert an array of properties ('key:value') into a hash
+        # Ex: ['width:50', 'height:100'] => { :width => '50', :height => '100' }
+        def args_to_options(*args)
+          options = {}
+          args.flatten.each do |a|
+            if (a =~ /^(.*):(.*)$/)
+              options[$1.to_sym] = $2
+            end
+          end
+          options
+        end
+
+        # Write options (Hash) into a string according to the following pattern:
+        # <key1>="<value1>", <key2>="<value2", ...etc
+        def inline_options(options = {})
+          return '' if options.empty?
+          (options.stringify_keys.sort.to_a.collect { |a, b| "#{a}=\"#{b}\"" }).join(' ') << ' '
+        end
+
+        def sort_input(input, property, order)
+          input.sort do |apple, orange|
+            apple_property = item_property(apple, property)
+            orange_property = item_property(orange, property)
+
+            if !apple_property.nil? && orange_property.nil?
+              - order
+            elsif apple_property.nil? && !orange_property.nil?
+              + order
+            else
+              apple_property <=> orange_property
+            end
+          end
+        end
+
+        def time(input)
+          case input
+          when Time
+            input.clone
+          when Date
+            input.to_time
+          when String
+            Time.parse(input) rescue Time.at(input.to_i)
+          when Numeric
+            Time.at(input)
+          else
+            raise Errors::InvalidDateError,
+              "Invalid Date: '#{input.inspect}' is not a valid datetime."
+          end.localtime
+        end
+
+        def groupable?(element)
+          element.respond_to?(:group_by)
+        end
+
+        def item_property(item, property)
+          if item.respond_to?(:to_liquid)
+            property.to_s.split(".").reduce(item.to_liquid) do |subvalue, attribute|
+              subvalue[attribute]
+            end
+          elsif item.respond_to?(:data)
+            item.data[property.to_s]
+          else
+            item[property.to_s]
+          end
+        end
+
+        def as_liquid(item)
+          case item
+          when Hash
+            pairs = item.map { |k, v| as_liquid([k, v]) }
+            Hash[pairs]
+          when Array
+            item.map { |i| as_liquid(i) }
+          else
+            if item.respond_to?(:to_liquid)
+              liquidated = item.to_liquid
+              # prevent infinite recursion for simple types (which return `self`)
+              if liquidated == item
+                item
+              else
+                as_liquid(liquidated)
+              end
+            else
+              item
+            end
+          end
+        end
+      end
+      ::Liquid::Template.register_filter(RedmineCrm::Liquid::Filters::Base)
+    end
+  end
+end

data/lib/redmine_crm/liquid/filters/colors.rb

@@ -0,0 +1,31 @@
+require 'liquid'
+
+module RedmineCrm
+  module Liquid
+    module Filters
+      module Colors
+        def darken_color(input, value=0.4)
+          RedmineCrm::ColorsHelper.darken_color(input, value.to_f)
+        end
+
+        def lighten_color(input, value=0.6)
+          RedmineCrm::ColorsHelper.lighten_color(input, value.to_f)
+        end
+
+        def contrasting_text_color(input)
+          RedmineCrm::ColorsHelper.contrasting_text_color(input)
+        end
+
+        def hex_color(input)
+          RedmineCrm::ColorsHelper.hex_color(input)
+        end
+
+        def convert_to_brightness_value(input)
+          RedmineCrm::ColorsHelper.convert_to_brightness_value(input)
+        end
+
+      end
+      ::Liquid::Template.register_filter(RedmineCrm::Liquid::Filters::Colors)
+    end
+  end
+end

data/lib/redmine_crm/money_helper.rb

@@ -1,5 +1,3 @@
-# byebug
-# require 'action_controller'
 require 'action_view'
 
 module RedmineCrm
@@ -41,9 +39,9 @@ module RedmineCrm
     end
 
     def all_currencies
-      Currency.table.inject([]) do |array, (id, attributes)|
+      Currency.table.inject([]) do |array, (_, attributes)|
         array ||= []
-        array << ["#{attributes[:name]}" + (attributes[:symbol].blank? ? "" : " (#{attributes[:symbol]})"), attributes[:iso_code]]
+        array << [attributes[:name].to_s + (attributes[:symbol].blank? ? '' : " (#{attributes[:symbol]})"), attributes[:iso_code]]
         array
       end.sort{|x, y| x[0] <=> y[0]}
     end

data/lib/redmine_crm/version.rb

@@ -1,3 +1,3 @@
 module RedmineCrm
-  VERSION = "0.0.23"
+  VERSION = '0.0.43'
 end

data/lib/redmine_crm.rb

@@ -1,27 +1,62 @@
-require "redmine_crm/version"
-
-require "redmine_crm/tag"
-require "redmine_crm/tag_list"
-require "redmine_crm/tagging"
-require "redmine_crm/rcrm_acts_as_taggable"
-require "redmine_crm/helpers/tags_helper"
-require "redmine_crm/currency"
-require "redmine_crm/money_helper"
-require "redmine_crm/rcrm_acts_as_votable"
-require "redmine_crm/rcrm_acts_as_voter"
-require "redmine_crm/vote"
-require "redmine_crm/voter"
-require "redmine_crm/rcrm_acts_as_viewed"
+require 'active_record'
+require 'action_view'
+
+require 'redmine_crm/version'
+
+require 'redmine_crm/acts_as_list/list'
+require 'redmine_crm/acts_as_taggable/tag'
+require 'redmine_crm/acts_as_taggable/tag_list'
+require 'redmine_crm/acts_as_taggable/tagging'
+require 'redmine_crm/acts_as_taggable/rcrm_acts_as_taggable'
+require 'redmine_crm/acts_as_viewed/rcrm_acts_as_viewed'
+require 'redmine_crm/acts_as_votable/rcrm_acts_as_votable'
+require 'redmine_crm/acts_as_votable/rcrm_acts_as_voter'
+require 'redmine_crm/acts_as_votable/vote'
+require 'redmine_crm/acts_as_votable/voter'
+require 'redmine_crm/acts_as_draftable/rcrm_acts_as_draftable'
+require 'redmine_crm/acts_as_draftable/draft'
+
+require 'redmine_crm/currency'
+require 'redmine_crm/helpers/tags_helper'
+require 'redmine_crm/money_helper'
+require 'redmine_crm/colors_helper'
+
+require 'liquid'
+require 'redmine_crm/liquid/filters/base'
+require 'redmine_crm/liquid/filters/arrays'
+require 'redmine_crm/liquid/filters/colors'
+require 'redmine_crm/liquid/drops/issues_drop'
+require 'redmine_crm/liquid/drops/news_drop'
+require 'redmine_crm/liquid/drops/projects_drop'
+require 'redmine_crm/liquid/drops/users_drop'
+require 'redmine_crm/liquid/drops/time_entries_drop'
+
+require 'redmine_crm/helpers/external_assets_helper'
+require 'redmine_crm/helpers/form_tag_helper'
+require 'redmine_crm/assets_manager'
+
+require 'redmine_crm/compatibility/application_controller_patch'
+
+module RedmineCrm
+  GEM_NAME = 'redmine_crm'.freeze
+end
 
 if defined?(ActiveRecord::Base)
-  ActiveRecord::Base.extend(RedmineCrm::ActsAsVotable::Votable)
+  ActiveRecord::Base.send :include, RedmineCrm::ActsAsList::List
   ActiveRecord::Base.extend(RedmineCrm::ActsAsVotable::Voter)
+  ActiveRecord::Base.extend(RedmineCrm::ActsAsVotable::Votable)
 end
 
-def requires_redmine_crm(arg)
+RedmineCrm::AssetsManager.install_assets
 
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, RedmineCrm::ExternalAssetsHelper
+  ActionView::Base.send :include, RedmineCrm::FormTagHelper
+end
+
+def requires_redmine_crm(arg)
   def compare_versions(requirement, current)
-    raise ArgumentError.new("wrong version format") unless check_version_format(requirement)
+    raise ArgumentError.new('wrong version format') unless check_version_format(requirement)
     requirement = requirement.split('.').collect(&:to_i)
     requirement <=> current.slice(0, requirement.size)
   end
@@ -33,11 +68,11 @@ def requires_redmine_crm(arg)
   arg = { :version_or_higher => arg } unless arg.is_a?(Hash)
   arg.assert_valid_keys(:version, :version_or_higher)
 
-  current = RedmineCrm::VERSION.split(".").map{|x| x.to_i}
+  current = RedmineCrm::VERSION.split('.').map { |x| x.to_i }
   arg.each do |k, req|
     case k
     when :version_or_higher
-      raise ArgumentError.new(":version_or_higher accepts a version string only") unless req.is_a?(String)
+      raise ArgumentError.new(':version_or_higher accepts a version string only') unless req.is_a?(String)
       unless compare_versions(req, current) <= 0
         Rails.logger.error "\033[31m[ERROR]\033[0m Redmine requires redmine_crm gem version #{req} or higher (you're using #{RedmineCrm::VERSION}).\n\033[31m[ERROR]\033[0m Please update with 'bundle update redmine_crm'." if Rails.logger
         abort "\033[31mRedmine requires redmine_crm gem version #{req} or higher (you're using #{RedmineCrm::VERSION}).\nPlease update with 'bundle update redmine_crm'.\033[0m"
@@ -53,9 +88,9 @@ def requires_redmine_crm(arg)
           abort "\033[31mRedmine requires redmine_crm gem version between #{req.first} and #{req.last} (you're using #{RedmineCrm::VERSION}).\nPlease update with 'bundle update redmine_crm'.\033[0m"
         end
       else
-        raise ArgumentError.new(":version option accepts a version string, an array or a range of versions")
+        raise ArgumentError.new(':version option accepts a version string, an array or a range of versions')
       end
     end
   end
   true
-end
+end

data/redmine_crm.gemspec

@@ -6,10 +6,10 @@ require 'redmine_crm/version'
 Gem::Specification.new do |spec|
   spec.name          = "redmine_crm"
   spec.version       = RedmineCrm::VERSION
-  spec.authors       = ["RedmineCRM"]
+  spec.authors       = ["RedmineUP"]
   spec.email         = ["support@redminecrm.com"]
-  spec.summary       = %q{Common libraries for RedmineCRM plugins for Redmine}
-  spec.description   = %q{Common libraries for RedmineCRM plugins for Redmine. Requered Redmine from http://redmine.org}
+  spec.summary       = %q{Common libraries for RedmineUP plugins for Redmine}
+  spec.description   = %q{Common libraries for RedmineUP plugins (www.redmineup.com) for Redmine. Requered Redmine from http://redmine.org}
   spec.homepage      = ""
   spec.license       = "GPL2"
 
@@ -18,5 +18,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-end
+  spec.add_runtime_dependency 'rails'
+  spec.add_runtime_dependency 'liquid', '< 2.6.4'
 
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'mysql2'
+  spec.add_development_dependency 'pg'
+end

data/test/acts_as_draftable/draft_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class DraftTest < ActiveSupport::TestCase
+  def test_restore
+    issue = Issue.new(subject: 'some subject', description: 'some description')
+
+    issue.save_draft
+    restored_issue = RedmineCrm::ActsAsDraftable::Draft.find(issue.draft_id).restore
+
+    assert_equal issue.subject, restored_issue.subject
+    assert_equal issue.description, restored_issue.description
+  end
+
+  def test_restore_all
+    first_issue = Issue.new(subject: 'first subject')
+    first_issue.save_draft
+    second_issue = Issue.new(subject: 'second subject')
+    second_issue.save_draft
+
+    restored_issues = RedmineCrm::ActsAsDraftable::Draft.restore_all
+    assert_equal [first_issue.subject, second_issue.subject], restored_issues.map(&:subject).sort
+  end
+
+  private
+
+  def current_user
+    users(:sam)
+  end
+end

data/test/acts_as_draftable/rcrm_acts_as_draftable_test.rb

@@ -0,0 +1,179 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class RcrmActsAsDraftableTest < ActiveSupport::TestCase
+  def test_rcrm_acts_as_draftable_without_arguments
+    assert_nothing_raised do
+      Project.rcrm_acts_as_draftable
+    end
+  end
+
+  class SomeClass < ActiveRecord::Base; end
+  def test_rcrm_acts_as_draftable_with_parent
+    assert_nothing_raised do
+      News.rcrm_acts_as_draftable(parent: :author)
+    end
+    assert User.new.respond_to?(:drafts)
+  end
+
+  def test_rcrm_acts_as_draftable_with_non_existing_parent
+    assert_raises do
+      Issue.rcrm_acts_as_draftable(parent: :foo)
+    end
+  end
+
+  def test_rcrm_acts_as_draftable_with_non_hash_argument
+    assert_raises do
+      Issue.rcrm_acts_as_draftable('bar')
+    end
+  end
+
+  def test_rcrm_acts_as_draftable_with_invalid_hash_key
+    assert_raises do
+      Issue.rcrm_acts_as_draftable(baz: 'qux')
+    end
+  end
+
+  def test_drafts
+    Issue.rcrm_acts_as_draftable parent: :project
+    issue = Issue.new
+    issue.save_draft
+
+    assert_equal 1, Issue.drafts(current_user).count
+    assert_equal RedmineCrm::ActsAsDraftable::Draft, Issue.drafts(current_user).first.class
+  end
+
+  def test_from_draft
+    Issue.rcrm_acts_as_draftable parent: :project
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft
+
+    issue_from_draft = Issue.from_draft(issue.draft_id)
+
+    assert_equal Issue, issue_from_draft.class
+    assert_equal true, issue_from_draft.new_record?
+    assert_equal issue.draft_id, issue_from_draft.draft_id
+
+    assert_equal issue.subject, issue_from_draft.subject
+  end
+
+  def test_draft_deleted_after_save
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft
+
+    issue_from_draft = Issue.from_draft(issue.draft_id)
+
+    assert_difference 'Issue.count' do
+      assert_difference 'RedmineCrm::ActsAsDraftable::Draft.count', -1 do
+        issue_from_draft.save!
+      end
+    end
+    assert_nil issue_from_draft.draft_id
+  end
+
+  def test_from_draft_with_non_existing_draft_id
+    assert_raises do
+      Issue.from_draft(999)
+    end
+  end
+
+  def test_from_draft_with_wrong_type
+    Project.rcrm_acts_as_draftable
+
+    project = Project.new
+    project.save_draft
+
+    assert_raises do
+      Issue.from_draft(project.draft_id)
+    end
+  end
+
+  def test_dump_to_draft
+    assert_equal String, Issue.new.dump_to_draft.class
+  end
+
+  def test_load_from_draft
+    attributes = {subject: 'subject', description: 'description'}
+    draft = Issue.new(attributes).dump_to_draft
+
+    issue = Issue.new
+    issue.load_from_draft(draft)
+
+    assert_equal attributes[:subject], issue.subject
+    assert_equal attributes[:description], issue.description
+  end
+
+  def test_save_draft
+    Issue.rcrm_acts_as_draftable parent: :project
+    attributes = { subject: 'subject' }
+    issue = Issue.new(attributes)
+
+    assert_no_difference 'Issue.count' do
+      assert_difference 'RedmineCrm::ActsAsDraftable::Draft.count' do
+        result = issue.save_draft
+        assert_equal true, result
+      end
+    end
+    assert_not_nil issue.draft_id
+
+    draft = RedmineCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal 'Issue', draft.target_type
+    assert_equal current_user.id, draft.user_id
+    assert_equal attributes[:subject], draft.restore.subject
+  end
+
+  def test_save_draft_with_associations
+    Issue.rcrm_acts_as_draftable parent: :project
+    issue = Issue.new(project: projects(:second_project))
+    issue.save_draft
+
+    draft = RedmineCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.project.name, draft.restore.project.name
+  end
+
+  def test_save_draft_updates_existing_draft
+    Issue.rcrm_acts_as_draftable parent: :project
+    issue = Issue.new
+    issue.save_draft
+
+    issue.subject = 'changed subject'
+    assert_no_difference 'Issue.count' do
+      assert_no_difference 'RedmineCrm::ActsAsDraftable::Draft.count' do
+        issue.save_draft
+      end
+    end
+
+    draft = RedmineCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  def test_save_draft_does_not_save_persisted_object
+    issue = issues(:second_issue)
+    assert_equal false, issue.save_draft
+  end
+
+  def test_save_draft_saves_persisted_but_changed_object
+    issue = issues(:second_issue)
+    issue.subject = 'changed subject'
+    assert_equal true, issue.save_draft
+  end
+
+  def test_update_draft
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft
+
+    assert_no_difference 'Issue.count' do
+      assert_no_difference 'RedmineCrm::ActsAsDraftable::Draft.count' do
+        issue.update_draft(subject: 'updated_subject')
+      end
+    end
+
+    draft = RedmineCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  private
+
+  def current_user
+    users(:sam)
+  end
+end