redmine_crm 0.0.23 → 0.0.53

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

@@ -0,0 +1,187 @@
+module RedmineCrm
+  module Liquid
+    module Filters
+      module Arrays
+
+        # Get the first element of the passed in array
+        #
+        # Example:
+        #    {{ product.images | first | to_img }}
+        # 
+        #    {{ product.images | first: 3 }}
+        #
+        def first(array, count=1)
+          (count > 1 ? array.first(count) : array.first) if array.respond_to?(:first)
+        end
+
+        # Convert the input into json string
+        #
+        # input - The Array or Hash to be converted
+        #
+        # Returns the converted json string
+        def jsonify(input)
+          as_liquid(input).to_json
+        end
+
+        # Group an array of items by a property
+        #
+        # input - the inputted Enumerable
+        # property - the property
+        #
+        # Returns an array of Hashes, each looking something like this:
+        #  {"name"  => "larry"
+        #   "items" => [...] } # all the items where `property` == "larry"
+        def group_by(input, property)
+          if groupable?(input)
+            input.group_by { |item| item_property(item, property).to_s }.each_with_object([]) do |item, array|
+                array << {
+                  "name"  => item.first,
+                  "items" => item.last,
+                  "size"  => item.last.size
+                }
+              end
+          else
+            input
+          end
+        end
+
+        # Filter an array of objects
+        #
+        # input - the object array
+        # property - property within each object to filter by
+        # value - desired value
+        #
+        # Returns the filtered array of objects
+        def where(input, property, value, operator='==')
+          return input unless input.respond_to?(:select)
+          input = input.values if input.is_a?(Hash)
+          if operator == '=='
+            input.select do |object|
+              Array(item_property(object, property)).map(&:to_s).include?(value.to_s)
+            end || []
+          elsif operator == '<>'
+            input.select do |object|
+              !Array(item_property(object, property)).map(&:to_s).include?(value.to_s)
+            end || []
+          elsif operator == '>'
+            input.select do |object|
+              item_property_value = item_property(object, property) 
+              item_property_value && item_property_value > value
+            end || []
+          elsif operator == '<'
+            input.select do |object|
+              item_property_value = item_property(object, property) 
+              item_property_value && item_property_value < value
+            end || []
+          elsif operator == 'match'
+            input.select do |object|
+              Array(item_property(object, property)).map(&:to_s).any?{|i| i.match(value.to_s)}
+            end || []
+          elsif operator == 'any'
+            input.select do |object|
+              item_property(object, property).present?
+            end || []
+          elsif operator == 'none'
+            input.select do |object|
+              item_property(object, property).blank?
+            end || []
+          else
+            []
+          end
+        end
+
+        # Filter an array of objects by tags
+        #
+        # input - the object array
+        # tags - quoted tags list divided by comma
+        # match - (all- defaut, any, exclude)
+        #
+        # Returns the filtered array of objects
+        def tagged_with(input, tags, match='all')
+          return input unless input.respond_to?(:select)
+          input = input.values if input.is_a?(Hash)
+          tag_list = tags.is_a?(Array) ? tags.sort : tags.split(',').map(&:strip).sort
+          case match
+          when "all"
+            input.select do |object|
+              object.respond_to?(:tag_list) &&
+              (tag_list - Array(item_property(object, 'tag_list')).map(&:to_s).sort).empty?
+            end || []
+          when "any"
+            input.select do |object|
+              object.respond_to?(:tag_list) &&
+              (tag_list & Array(item_property(object, 'tag_list')).map(&:to_s).sort).any?
+            end || []
+          when "exclude"
+            input.select do |object|
+              object.respond_to?(:tag_list) &&
+              (tag_list & Array(item_property(object, 'tag_list')).map(&:to_s).sort).empty?
+            end || []
+          else
+            []
+          end
+        end
+
+        # Sort an array of objects
+        #
+        # input - the object array
+        # property - property within each object to filter by
+        # nils ('first' | 'last') - nils appear before or after non-nil values
+        #
+        # Returns the filtered array of objects
+        def sort(input, property = nil, nils = "first")
+          if input.nil?
+            raise ArgumentError, "Cannot sort a null object."
+          end
+          if property.nil?
+            input.sort
+          else
+            if nils == "first"
+              order = - 1
+            elsif nils == "last"
+              order = + 1
+            else
+              raise ArgumentError, "Invalid nils order: " \
+                "'#{nils}' is not a valid nils order. It must be 'first' or 'last'."
+            end
+
+            sort_input(input, property, order)
+          end
+        end
+
+        def pop(array, input = 1)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.pop(input.to_i || 1)
+          new_ary
+        end
+
+        def push(array, input)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.push(input)
+          new_ary
+        end
+
+        def shift(array, input = 1)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.shift(input.to_i || 1)
+          new_ary
+        end
+
+        def unshift(array, input)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.unshift(input)
+          new_ary
+        end
+
+        private
+
+      end # module ArrayFilters
+    end
+  end
+
+  ::Liquid::Template.register_filter(RedmineCrm::Liquid::Filters::Arrays)
+end

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,16 +1,14 @@
-# byebug
-# require 'action_controller'
 require 'action_view'
+require 'redmine_crm/settings/money'
 
 module RedmineCrm
   module MoneyHelper
-
     def object_price(obj, price_field = :price, options = {})
       options.merge!({:symbol => true})
       price_to_currency(obj.try(price_field), obj.currency, options).to_s if obj.respond_to?(:currency)
     end
 
-    def prices_collection_by_currency(prices_collection, options={})
+    def prices_collection_by_currency(prices_collection, options = {})
       return [] if prices_collection.blank? || prices_collection == 0
       prices = prices_collection
       prices.reject!{|k, v| v.to_i == 0} if options[:hide_zeros]
@@ -20,17 +18,17 @@ module RedmineCrm
     def deal_currency_icon(currency)
       case currency.to_s.upcase
       when 'EUR'
-        "icon-money-euro"
+        'icon-money-euro'
       when 'GBP'
-        "icon-money-pound"
+        'icon-money-pound'
       when 'JPY'
-        "icon-money-yen"
+        'icon-money-yen'
       else
-        "icon-money-dollar"
+        'icon-money-dollar'
       end
     end
 
-    def collection_for_currencies_select(default_currency = 'USD', major_currencies = %w(USD EUR GBP RUB CHF))
+    def collection_for_currencies_select(default_currency = RedmineCrm::Settings::Money.default_currency, major_currencies = RedmineCrm::Settings::Money.major_currencies)
       currencies = []
       currencies << default_currency.to_s unless default_currency.blank?
       currencies |= major_currencies
@@ -41,24 +39,25 @@ 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
 
-    def price_to_currency(price, currency="USD", options={})
+    def price_to_currency(price, currency = RedmineCrm::Settings::Money.default_currency, options = {})
       return '' if price.blank?
 
-      currency = "USD" unless currency.is_a?(String)
-      currency = RedmineCrm::Currency.find(currency)
+      currency = 'USD' unless currency.is_a?(String)
+      default_options = {
+        decimal_mark: RedmineCrm::Settings::Money.decimal_separator,
+        thousands_separator: RedmineCrm::Settings::Money.thousands_delimiter
+      }.reject { |_k, v| v.nil? }
 
-      return RedmineCrm::Currency.format(price.to_f, currency, options)# if currency
-      price.to_s
+      currency = RedmineCrm::Currency.find(currency)
+      RedmineCrm::Currency.format(price.to_f, currency, default_options.merge(options))
     end
-
-
   end
 end
 

data/lib/redmine_crm/settings/money.rb

@@ -0,0 +1,46 @@
+require 'redmine_crm/settings'
+
+module RedmineCrm
+  class Settings
+    class Money
+      TAX_TYPE_EXCLUSIVE = 1
+      TAX_TYPE_INCLUSIVE = 2
+
+      class << self
+        def default_currency
+          RedmineCrm::Settings['default_currency'] || 'USD'
+        end
+
+        def major_currencies
+          currencies = RedmineCrm::Settings['major_currencies'].to_s.split(',').select { |c| !c.blank? }.map(&:strip)
+          currencies = %w[USD EUR GBP RUB CHF] if currencies.blank?
+          currencies.compact.uniq
+        end
+
+        def default_tax
+          RedmineCrm::Settings['default_tax'].to_f
+        end
+
+        def tax_type
+          ((['1', '2'] & [RedmineCrm::Settings['tax_type'].to_s]).first || TAX_TYPE_EXCLUSIVE).to_i
+        end
+
+        def tax_exclusive?
+          tax_type == TAX_TYPE_EXCLUSIVE
+        end
+
+        def thousands_delimiter
+          ([' ', ',', '.'] & [RedmineCrm::Settings['thousands_delimiter']]).first
+        end
+
+        def decimal_separator
+          ([',', '.'] & [RedmineCrm::Settings['decimal_separator']]).first
+        end
+
+        def disable_taxes?
+          RedmineCrm::Settings['disable_taxes'].to_i > 0
+        end
+      end
+    end
+  end
+end

data/lib/redmine_crm/settings.rb

@@ -0,0 +1,53 @@
+module RedmineCrm
+  class Settings
+    SECTIONS = {
+      'money' => { id: :money, label: :label_redmine_crm_money, partial: 'money' }
+    }.freeze
+
+    class << self
+      def initialize_gem_settings
+        return if !Object.const_defined?('Setting') || Setting.respond_to?(:plugin_redmine_crm)
+
+        if Setting.respond_to?(:define_setting)
+          Setting.send(:define_setting, 'plugin_redmine_crm', 'default' => default_settings, 'serialized' => true)
+        elsif Setting.respond_to?(:available_settings)
+          Setting.available_settings['plugin_redmine_crm'] = { 'default' => default_settings, 'serialized' => true }
+          Setting.class.send(:define_method, 'plugin_redmine_crm', -> { Setting['plugin_redmine_crm'] })
+          Setting.class.send(:define_method, 'plugin_redmine_crm=', lambda do |val|
+            setting = find_or_default('plugin_redmine_crm')
+            setting.value = val || ''
+            @cached_settings['plugin_redmine_crm'] = nil
+            setting.save(validate: false)
+            setting.value
+          end)
+        end
+        @settings_initialized
+      end
+
+      # Use apply instead attrs assign because it can rewrite other attributes
+      def apply=(values)
+        initialize_gem_settings unless @settings_initialized
+
+        Setting.plugin_redmine_crm = Setting.plugin_redmine_crm.merge(values)
+      end
+
+      def values
+        initialize_gem_settings unless @settings_initialized
+        Object.const_defined?('Setting') ? Setting.plugin_redmine_crm : {}
+      end
+
+      def [](value)
+        initialize_gem_settings unless @settings_initialized
+        return Setting.plugin_redmine_crm[value] if Object.const_defined?('Setting')
+
+        nil
+      end
+
+      private
+
+      def default_settings
+        {}
+      end
+    end
+  end
+end

data/lib/redmine_crm/version.rb

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