yeshoua_crm 1.0.0

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

@@ -0,0 +1,208 @@
+require 'uri'
+require 'rack'
+require 'json'
+require 'date'
+require 'liquid'
+
+module YeshouaCrm
+  module Liquid
+    module Filters
+      module Base
+        include YeshouaCrm::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 = 'BRL')
+          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_fields)
+            input.custom_fields[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)
+            item.to_liquid[property.to_s]
+          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(YeshouaCrm::Liquid::Filters::Base)
+    end
+  end
+end

data/lib/yeshoua_crm/money_helper.rb

@@ -0,0 +1,65 @@
+require 'action_view'
+
+module YeshouaCrm
+  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={})
+      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 = 'BRL', major_currencies = %w(BRL USD EUR GBP RUB CHF))
+      currencies = []
+      currencies << default_currency.to_s unless default_currency.blank?
+      currencies |= major_currencies
+      currencies.map do |c|
+        currency = YeshouaCrm::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="BRL", options={})
+      return '' if price.blank?
+
+      currency = "BRL" unless currency.is_a?(String)
+      currency = YeshouaCrm::Currency.find(currency)
+
+      return YeshouaCrm::Currency.format(price.to_f, currency, options)# if currency
+      price.to_s
+    end
+
+
+  end
+end
+
+unless ActionView::Base.included_modules.include?(YeshouaCrm::MoneyHelper)
+  ActionView::Base.send(:include, YeshouaCrm::MoneyHelper)
+end

data/lib/yeshoua_crm/version.rb

@@ -0,0 +1,3 @@
+module YeshouaCrm
+  VERSION = "1.0.0"
+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(current_user)
+    restored_issue = YeshouaCrm::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(current_user)
+    second_issue = Issue.new(subject: 'second subject')
+    second_issue.save_draft(current_user)
+
+    restored_issues = YeshouaCrm::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,185 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class RcrmActsAsDraftableTest < ActiveSupport::TestCase
+  def test_rcrm_acts_as_draftable_without_arguments
+    assert_nothing_raised do
+      Cell.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 = Issue.new
+    issue.save_draft(current_user)
+
+    assert_equal 1, Issue.drafts(current_user).count
+    assert_equal YeshouaCrm::ActsAsDraftable::Draft, Issue.drafts(current_user).first.class
+  end
+
+  def test_from_draft
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft(current_user)
+
+    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(current_user)
+
+    issue_from_draft = Issue.from_draft(issue.draft_id)
+
+    assert_difference 'Issue.count', 1 do
+      assert_difference 'YeshouaCrm::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
+    Cell.rcrm_acts_as_draftable
+
+    cell = Cell.new
+    cell.save_draft(current_user)
+
+    assert_raises do
+      Issue.from_draft(cell.draft_id)
+    end
+  end
+
+  def test_dump_to_draft
+    assert_equal String, Issue.new.dump_to_draft.class
+  end
+
+  def test_load_to_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
+    attributes = {subject: 'subject'}
+    issue = Issue.new(attributes)
+
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshouaCrm::ActsAsDraftable::Draft.count', 1 do
+        result = issue.save_draft(current_user)
+        assert_equal true, result
+      end
+    end
+    assert_equal Fixnum, issue.draft_id.class
+
+
+    draft = YeshouaCrm::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_without_user
+    issue = Issue.new
+
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshouaCrm::ActsAsDraftable::Draft.count', 1 do
+        result = issue.save_draft
+        assert_equal true, result
+      end
+    end
+
+    draft = YeshouaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_nil draft.user_id
+  end
+
+  def test_save_draft_with_associations
+    issue = Issue.new(cell: cells(:second_cell))
+    issue.save_draft(current_user)
+
+    draft = YeshouaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.cell.name, draft.restore.cell.name
+  end
+
+  def test_save_draft_updates_existing_draft
+    issue = Issue.new
+    issue.save_draft(current_user)
+
+    issue.subject = 'changed subject'
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshouaCrm::ActsAsDraftable::Draft.count', 0 do
+        issue.save_draft(current_user)
+      end
+    end
+
+    draft = YeshouaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  def test_save_draft_does_not_save_persisted_model
+    issue = Issue.new
+    issue.save_draft(current_user)
+    issue.save!
+    assert_equal false, issue.save_draft(current_user)
+  end
+
+  def test_update_draft
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft(current_user)
+
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshouaCrm::ActsAsDraftable::Draft.count', 0 do
+        issue.update_draft(current_user, subject: 'updated_subject')
+      end
+    end
+
+    draft = YeshouaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  private
+
+  def current_user
+    users(:sam)
+  end
+end