redmine_crm 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3661b03ec0c3d09a9c41e80181930cd950f00cbe
-  data.tar.gz: 953749b65190d3682c9aed7a8ecca66174c9c78e
+  metadata.gz: 6c8441e8bec7aa49ee5f7c391e66cc174da87266
+  data.tar.gz: dfddb0ee0c407a3e3d6bc1d6e4ff91bf3e6816df
 SHA512:
-  metadata.gz: e2bfe39d6138293c2ac1456003cf885094b7961f6c30e87b4bf1276bcd7a565746a58bbd489c98454f0afc71aa8b8f21fe02573dd063bd7bb3d90d9bcefe0f36
-  data.tar.gz: c85726be43588829945a3f84c300e9d0345bfc9c0d7149fc4c5080db507b587a796c77bfbe5a206366b469509929f0eb7a5e8de5401845c87800f95aee880ef3
+  metadata.gz: 56a5b5fc3381ee13dff3740e0c0f027b13db220e5571f1027b3829acf74eddeaa76102f9dca14cd3dbe8122c57862130c44af839c4b02115ec8d2f5f4741827a
+  data.tar.gz: 34b79fa7e7ca483f9e3ad606c92e421f8409617ffa7f623d6a5018b26ad4f2280c3577ec464ed48f2f1e75104633e7336d1d5ad6d533f68dc744080890aacdf0

data/lib/redmine_crm.rb

@@ -6,3 +6,4 @@ require "redmine_crm/tagging"
 require "redmine_crm/rcrm_acts_as_taggable"
 require "redmine_crm/tags_helper"
 require "redmine_crm/currency"
+require "redmine_crm/money_helper"

data/lib/redmine_crm/currency.rb

@@ -1,6 +1,8 @@
 require "json"
 require "redmine_crm/currency/loader"
 require "redmine_crm/currency/heuristics"
+require "redmine_crm/currency/formatting"
+
 module RedmineCrm
   # Represents a specific currency unit.
   #
@@ -11,6 +13,9 @@ module RedmineCrm
     extend Enumerable
     extend RedmineCrm::Currency::Loader
     extend RedmineCrm::Currency::Heuristics
+    extend RedmineCrm::Currency::Formatting
+
+
 
     # Thrown when a Currency has been registered without all the attributes
     # which are required for the current action.
@@ -177,7 +182,6 @@ module RedmineCrm
         all.each { |c| yield(c) }
       end
 
-
       private
 
       def stringify_keys
@@ -296,6 +300,7 @@ module RedmineCrm
                           end
       self.id.to_s.downcase == other_currency_id
     end
+    
     private :compare_ids
 
     # Returns a Fixnum hash value based on the +id+ attribute in order to use
@@ -396,7 +401,7 @@ module RedmineCrm
     end
 
     private
-
+      
     def cache
       self.class.decimal_places_cache
     end

data/lib/redmine_crm/currency/formatting.rb

@@ -0,0 +1,221 @@
+# encoding: UTF-8
+module RedmineCrm
+  class Currency
+    module Formatting
+      def self.included(base)
+        [
+          [:thousands_separator, :delimiter, ","],
+          [:decimal_mark, :separator, "."]
+        ].each do |method, name, character|
+          define_i18n_method(method, name, character)
+        end
+      end
+
+      def self.define_i18n_method(method, name, character)
+        define_method(method) do
+          if self.class.use_i18n
+            begin
+              I18n.t name, :scope => "number.currency.format", :raise => true
+            rescue I18n::MissingTranslationData
+              I18n.t name, :scope =>"number.format", :default => (currency.send(method) || character)
+            end
+          else
+            currency.send(method) || character
+          end
+        end
+        alias_method name, method
+      end
+
+     
+      def format(value, currency, *rules)
+        # support for old format parameters
+        rules = normalize_formatting_rules(rules)
+        # byebug
+        rules = Currency.default_formatting_rules.merge(rules)
+        rules = self.localize_formatting_rules(rules, currency)
+        rules = self.translate_formatting_rules(rules, currency.code) if rules[:translate]
+
+        # if fractional == 0
+        if rules[:display_free].respond_to?(:to_str)
+          return rules[:display_free]
+        elsif rules[:display_free]
+          return "free"
+        end
+        # end
+
+        symbol_value = currency.symbol
+
+        formatted = value.abs.to_s
+
+        # if rules[:rounded_infinite_precision]
+          formatted.gsub!(/#{currency.decimal_mark}/, '.') unless '.' == currency.decimal_mark
+          formatted = ((BigDecimal(formatted) * currency.subunit_to_unit).round / BigDecimal(currency.subunit_to_unit.to_s)).to_s("F")
+          formatted.gsub!(/\..*/) do |decimal_part|
+            decimal_part << '0' while decimal_part.length < (currency.decimal_places + 1)
+            decimal_part
+          end
+          formatted.gsub!(/\./, currency.decimal_mark) unless '.' == currency.decimal_mark
+        # end
+
+        sign = value < 0 ? '-' : ''
+
+        if rules[:no_cents] || (rules[:no_cents_if_whole] && cents % currency.subunit_to_unit == 0)
+          formatted = "#{formatted.to_i}"
+        end
+
+        thousands_separator_value = currency.thousands_separator
+        # Determine thousands_separator
+        if rules.has_key?(:thousands_separator)
+          thousands_separator_value = rules[:thousands_separator] || ''
+        end
+
+        # Apply thousands_separator
+        formatted.gsub!(regexp_format(formatted, rules, currency.decimal_mark, symbol_value),
+                        "\\1#{thousands_separator_value}")
+
+        symbol_position = symbol_position_from(rules, currency)
+
+        if rules[:sign_positive] == true && (value >= 0)
+          sign = '+'
+        end
+
+        if rules[:sign_before_symbol] == true
+          sign_before = sign
+          sign = ''
+        end
+
+        if symbol_value && !symbol_value.empty?
+          symbol_value = "<span class=\"currency_symbol\">#{symbol_value}</span>" if rules[:html_wrap_symbol]
+
+          formatted = if symbol_position == :before
+            symbol_space = rules[:symbol_before_without_space] === false ? " " : ""
+            "#{sign_before}#{symbol_value}#{symbol_space}#{sign}#{formatted}"
+          else
+            symbol_space = rules[:symbol_after_without_space] ? "" : " "
+            "#{sign_before}#{sign}#{formatted}#{symbol_space}#{symbol_value}"
+          end
+        else
+          formatted="#{sign_before}#{sign}#{formatted}"
+        end
+
+        apply_decimal_mark_from_rules(formatted, rules)
+
+        if rules[:with_currency]
+          formatted << " "
+          formatted << '<span class="currency">' if rules[:html]
+          formatted << currency.to_s
+          formatted << '</span>' if rules[:html]
+        end
+        formatted
+      end
+
+      def default_formatting_rules
+        # byebug
+        {}
+      end
+
+      def regexp_format(formatted, rules, decimal_mark, symbol_value)
+        regexp_decimal = Regexp.escape(decimal_mark)
+        if rules[:south_asian_number_formatting]
+          /(\d+?)(?=(\d\d)+(\d)(?:\.))/
+        else
+          # Symbols may contain decimal marks (E.g "դր.")
+          if formatted.sub(symbol_value.to_s, "") =~ /#{regexp_decimal}/
+            /(\d)(?=(?:\d{3})+(?:#{regexp_decimal}))/
+          else
+            /(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/
+          end
+        end
+      end
+
+      def translate_formatting_rules(rules, iso_code)
+        begin
+          rules[:symbol] = I18n.t iso_code, :scope => "number.currency.symbol", :raise => true
+        rescue I18n::MissingTranslationData
+          # Do nothing
+        end
+        rules
+      end
+
+      def localize_formatting_rules(rules, currency)
+        if currency.iso_code == "JPY" && I18n.locale == :ja
+          rules[:symbol] = "円" unless rules[:symbol] == false
+          rules[:symbol_position] = :after
+          rules[:symbol_after_without_space] = true
+        end
+        rules
+      end
+
+      def symbol_value_from(rules)
+        if rules.has_key?(:symbol)
+          if rules[:symbol] === true
+            symbol
+          elsif rules[:symbol]
+            rules[:symbol]
+          else
+            ""
+          end
+        elsif rules[:html]
+          currency.html_entity == '' ? currency.symbol : currency.html_entity
+        elsif rules[:disambiguate] and currency.disambiguate_symbol
+          currency.disambiguate_symbol
+        else
+          symbol
+        end
+      end
+
+      def symbol_position_from(rules, currency)
+        if rules.has_key?(:symbol_position)
+          if [:before, :after].include?(rules[:symbol_position])
+            return rules[:symbol_position]
+          else
+            raise ArgumentError, ":symbol_position must be ':before' or ':after'"
+          end
+        elsif currency.symbol_first?
+          :before
+        else
+          :after
+        end
+      end
+
+      private
+
+      # Cleans up formatting rules.
+      #
+      # @param [Hash] rules
+      #
+      # @return [Hash]
+      def normalize_formatting_rules(rules)
+        if rules.size == 0
+          rules = {}
+        elsif rules.size == 1
+          rules = rules.pop
+          rules = { rules => true } if rules.is_a?(Symbol)
+        end
+        if !rules.include?(:decimal_mark) && rules.include?(:separator)
+          rules[:decimal_mark] = rules[:separator]
+        end
+        if !rules.include?(:thousands_separator) && rules.include?(:delimiter)
+          rules[:thousands_separator] = rules[:delimiter]
+        end
+        rules
+      end
+
+      # Applies decimal mark from rules to formatted
+      #
+      # @param [String] formatted
+      # @param [Hash]   rules
+      def apply_decimal_mark_from_rules(formatted, rules)
+        if rules.has_key?(:decimal_mark) && rules[:decimal_mark] &&
+          rules[:decimal_mark] != decimal_mark
+
+          regexp_decimal = Regexp.escape(decimal_mark)
+          formatted.sub!(/(.*)(#{regexp_decimal})(.*)\Z/,
+                         "\\1#{rules[:decimal_mark]}\\3")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/redmine_crm/money_helper.rb

@@ -0,0 +1,71 @@
+# byebug
+# require 'action_controller'
+require 'action_view'
+
+module RedmineCrm
+  module MoneyHelper
+
+    def object_price(obj, price_field = :price)
+      price_to_currency(obj.try(price_field), obj.currency, :symbol => true).to_s if obj.respond_to?(:currency)
+    end
+
+    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]
+      prices.collect{|k, v| content_tag(:span, price_to_currency(v, k, :symbol => true), :style => "white-space: nowrap;")}.compact
+    end
+
+    def deal_currency_icon(currency)
+      case currency.to_s.upcase
+      when 'EUR'
+        "icon-money-euro"
+      when 'GBP'
+        "icon-money-pound"
+      when 'JPY'
+        "icon-money-yen"
+      else
+        "icon-money-dollar"
+      end
+    end
+
+    def collection_for_currencies_select(default_currency = ContactsSetting.default_currency)
+      major_currencies_collection(default_currency)
+    end
+
+    def major_currencies_collection(default_currency)
+      currencies = []
+      currencies << default_currency.to_s unless default_currency.blank?
+      currencies |= ContactsSetting.major_currencies
+      currencies.map do |c|
+        currency = RedmineCrm::Currency.find(c)
+        ["#{currency.iso_code} (#{currency.symbol})", currency.iso_code] if currency
+      end.compact.uniq
+    end
+
+    def all_currencies
+      Currency.table.inject([]) do |array, (id, attributes)|
+        array ||= []
+        array << ["#{attributes[:name]}" + (attributes[:symbol].blank? ? "" : " (#{attributes[:symbol]})"), attributes[:iso_code]]
+        array
+      end.sort{|x, y| x[0] <=> y[0]}
+    end
+
+    def price_to_currency(price, currency=RedmineCrm::Currency.find("USD"), options={})
+      return '' if price.blank?
+        
+      if currency.is_a? String
+        currency = RedmineCrm::Currency.find(currency)
+      else
+        currency = RedmineCrm::Currency.find("USD")
+      end
+      RedmineCrm::Currency.format(price.to_f, currency)
+    end
+
+
+  end
+end
+
+unless ActionView::Base.included_modules.include?(RedmineCrm::MoneyHelper)
+  ActionView::Base.send(:include, RedmineCrm::MoneyHelper)
+end

data/lib/redmine_crm/rcrm_acts_as_taggable.rb

@@ -93,7 +93,7 @@ module RedmineCrm
           
           return [] if related_models.blank?
           
-          related_ids = related_models.ids.join(",")
+          related_ids = related_models.map{|c| c.id }.join(",")
           Tag.select( #find(:all, options.merge({
             "#{Tag.table_name}.*, COUNT(#{Tag.table_name}.id) AS count").joins(
             "JOIN #{Tagging.table_name} ON #{Tagging.table_name}.taggable_type = '#{base_class.name}'
@@ -112,7 +112,7 @@ module RedmineCrm
         #   :conditions - A piece of SQL conditions to add to the query
         def find_tagged_with(*args)
           options = find_options_for_find_tagged_with(*args)
-          options.blank? ? [] : select(options[:select]).where(options[:conditions]).joins(options[:joins]).order(options[:order])
+          options.blank? ? [] : select(options[:select]).where(options[:conditions]).joins(options[:joins]).order(options[:order]).to_a
           # find(:all, options)
         end
         alias_method :tagged_with, :find_tagged_with
@@ -148,7 +148,7 @@ module RedmineCrm
             end
           end
           
-          { :select => "DISTINCT #{table_name}.id ",
+          { :select => "DISTINCT #{table_name}.* ",
             :joins => joins.join(" "),
             :conditions => conditions.join(" AND ")
           }.reverse_merge!(options)

data/lib/redmine_crm/version.rb

@@ -1,3 +1,3 @@
 module RedmineCrm
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/test/money_helper_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MoneyHelperTest < ActiveSupport::TestCase
+  include RedmineCrm::MoneyHelper
+
+  def test_price_to_currency
+    assert_equal '$3,265.65', price_to_currency(3265.65, "USD")
+    assert_equal "3.265,65 ₽", price_to_currency(3265.65, "RUB")
+  end
+end

data/test/tag_test.rb

@@ -11,7 +11,7 @@ module RedmineCrm
       t = Tag.create!(:name => "My tag")
       duplicate = t.dup
       assert !duplicate.save
-      assert_match /taken/, duplicate.errors[:name].to_s
+      assert_match /not uniq/, duplicate.errors[:name].to_s
     end
     
     def test_taggings

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redmine_crm
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - RedmineCRM
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-08 00:00:00.000000000 Z
+date: 2015-06-10 00:00:00.000000000 Z
 dependencies: []
 description: plugins for Redmine
 email:
@@ -27,8 +27,10 @@ files:
 - lib/generators/redmine_crm_migration/templates/migration.rb
 - lib/redmine_crm.rb
 - lib/redmine_crm/currency.rb
+- lib/redmine_crm/currency/formatting.rb
 - lib/redmine_crm/currency/heuristics.rb
 - lib/redmine_crm/currency/loader.rb
+- lib/redmine_crm/money_helper.rb
 - lib/redmine_crm/rcrm_acts_as_taggable.rb
 - lib/redmine_crm/tag.rb
 - lib/redmine_crm/tag_list.rb
@@ -45,6 +47,7 @@ files:
 - test/fixtures/tags.yml
 - test/fixtures/user.rb
 - test/fixtures/users.yml
+- test/money_helper_test.rb
 - test/schema.rb
 - test/tag_test.rb
 - test/tagging_test.rb
@@ -84,6 +87,7 @@ test_files:
 - test/fixtures/tags.yml
 - test/fixtures/user.rb
 - test/fixtures/users.yml
+- test/money_helper_test.rb
 - test/schema.rb
 - test/tag_test.rb
 - test/tagging_test.rb