snappler_contable_multicurrency 2.2.0

data/app/helpers/snappler_contable_helper.rb

@@ -0,0 +1,42 @@
+module SnapplerContableHelper
+
+  #---------------------------------------------------------------
+  def print_accounts_tree
+    accounts = SnapplerContable.root_accounts
+    html_return = '<style>#account_list b{float: right;}#account_list li{border-bottom: 1px dashed;}#account_list ul{padding-left: 15px;}#account_list b .column{display: inline-block;text-align: center;width: 150px;}</style>'
+    html_return += '<div id="account_list">'
+    html_return += print_accounts(accounts)
+    html_return += '</div>'
+    html_return.html_safe
+  end
+
+  def print_accounts(accounts)
+    html_return = "<ul>"
+    accounts.each do |account|
+      html_return += print_account(account)
+    end 
+    html_return += "</ul>"
+    return html_return
+  end
+
+  def print_account(account)
+    if(account.child_ledger_accounts.empty?)
+      return "<li>#{account.name} <b>#{number_to_all_currency account.balance}</b></li>"
+    else
+      return %{<li>#{account.name} <b>#{number_to_all_currency account.balance}</b></li>
+      <ul>
+      #{print_accounts(account.child_ledger_accounts)}
+      </ul>
+    }
+    end
+  end
+
+  def number_to_all_currency(hash, reject_zero=false)
+    hash.reject!{|x,y| y.zero?} if reject_zero
+    hash.empty? ? '-' : hash.map{|key,val| number_to_currency(val, unit: t(key, scope: 'ledger_currency'), format: "%u %n") }.collect{|x| "<span class='column'>#{x}</span>" }.join()
+  end
+
+
+
+end
+

data/app/models/ledger_account.rb

@@ -0,0 +1,217 @@
+class LedgerAccount < ActiveRecord::Base
+
+
+
+    #--------------------------------------------- RELATIONS
+    belongs_to :owner, polymorphic: true, optional: true
+    belongs_to :master_ledger_account, class_name: "LedgerAccount", optional: true
+    has_many :child_ledger_accounts, class_name: "LedgerAccount", foreign_key: "master_ledger_account_id"
+    has_many :ledger_moves, dependent: :destroy
+
+    has_many :father_relations, class_name: "LedgerAccountRelation", foreign_key: :ledger_account_child_id, dependent: :destroy
+    has_many :fathers, through: :father_relations, source: :ledger_account_father
+    has_many :child_relations, class_name: "LedgerAccountRelation", foreign_key: :ledger_account_father_id
+    has_many :childs, through: :child_relations, source: :ledger_account_child
+
+    #--------------------------------------------- VALIDATIONS
+    validates :name, presence: true
+    validates :code_name, uniqueness: true
+
+    #--------------------------------------------- CALLBACKS
+    after_create :set_ledger_account_relations
+
+    #--------------------------------------------- SCOPES
+
+
+    #--------------------------------------------- METHODS
+
+    #devuelve la cuenta (de clase)
+    def self.get(value)
+      find_by(code_name: value.to_s.snp_underscore)
+    end
+
+    #--------------------
+    #Crea las relaciones de la cuenta con sus padres, todos los niveles
+    #se va mandando recursivamente la cuenta creada a sus padres
+    def set_ledger_account_relations
+      if master_ledger_account.present?
+        master_ledger_account.add_relation_child(self)
+      end
+    end
+
+    def add_relation_child(account)
+      self.childs << account
+      if master_ledger_account.present?
+        master_ledger_account.add_relation_child(account)
+      end
+    end
+    #-----------------------------------
+
+    #-----------------------------------
+    #Agrega una cuenta hija, con o sin relacion con un objeto
+    def add_child(name, code_name, owner=nil)
+      if persisted?
+        if owner.nil?
+          self.class.create(name: name, code_name: code_name, master_ledger_account: self)    
+        else
+          self.class.create(name: name, master_ledger_account: self, owner: owner, code_name: "#{code_name}_#{owner.class.name.underscore}_#{owner.id}")
+        end
+      else
+        errores = ["La instancia debe estar persistida para poder agregar una cuenta hija."]
+        errores << "La cuenta '#{name}' no se pudo persistir porque sus campos no cumplen la validacion de LedgerAccount." if errors.any?
+        raise errores.join(' ')
+      end
+    end
+    #-----------------------------------
+
+    def to_s
+      name
+    end
+
+    def name
+      internal_name
+    end
+
+    def name=(value)
+      self.internal_name = value
+      self.code_name = value.snp_underscore if code_name.blank?
+    end
+
+    def root?
+      master_ledger_account.nil?
+    end
+
+    def has_ledger_moves?
+      ledger_moves.any?
+    end
+
+
+    def balance(params={}, format_value=true)
+      from_date    = params[:from]
+      to_date      = params[:to]
+      balance_hash = {}
+
+      if from_date.nil? && to_date.nil?
+        SnapplerContable.used_currencies.each do |c|
+          balance_hash[c.to_sym] = self.send("normal_balance_#{c.downcase}", format_value)
+        end
+      elsif from_date.present? && to_date.present?
+        SnapplerContable.used_currencies.each do |c|
+          balance_hash[c.to_sym] = self.send("balance_from_to_#{c.downcase}", format_value, from_date, to_date)
+        end
+      elsif from_date.present?
+        SnapplerContable.used_currencies.each do |c|
+          balance_hash[c.to_sym] = self.send("balance_from_#{c.downcase}", format_value, from_date)
+        end
+      else
+        SnapplerContable.used_currencies.each do |c|
+          balance_hash[c.to_sym] = self.send("balance_to_#{c.downcase}", format_value, to_date)
+        end
+      end
+      return balance_hash
+    end
+
+
+    SnapplerContable.used_currencies.each do |c|
+      c = c.downcase # ARS => ars
+
+      #Metodo que en base a los parametros, busca saldo en cache o por rango de fecha
+      define_method "balance_#{c}" do |params={}, format_value=true|
+        from_date    = params[:from]
+        to_date      = params[:to]
+        if from_date.nil? && to_date.nil?
+          self.send("normal_balance_#{c}", format_value)
+        elsif from_date.present? && to_date.present?
+          self.send("balance_from_to_#{c}", format_value, from_date, to_date)
+        elsif from_date.present?
+          self.send("balance_from_#{c}", format_value, from_date)
+        else
+          self.send("balance_to#{c}", format_value, to_date)
+        end
+      end
+
+      #Saldo en cache
+      define_method "normal_balance_#{c}" do |format_value|
+        balance_sum_currency = "balance_sum_#{c}".to_sym
+        val = LedgerAccount.where(id: child_ids+[self.id]).sum(balance_sum_currency)
+        (format_value)? LedgerMove.format_value(val) : val
+      end
+
+      #Saldo hasta
+      define_method "balance_to_#{c}" do |format_value, to_date|
+        ledger_currency = get_currency(c.upcase)
+        #process(children_moves.where('date <= ? AND represent_ledger_currency_id = ?', to_date, ledger_currency.id).group(:dh).sum(:represent_value), format_value)
+        process(children_moves.filter_date_end(to_date).where('represent_ledger_currency_id = ?', ledger_currency.id).group(:dh).sum(:represent_value), format_value)
+      end
+
+      #Saldo desde
+      define_method "balance_from_#{c}" do |format_value, from_date|
+        ledger_currency = get_currency(c.upcase)
+        #process(children_moves.where('date >= ? AND represent_ledger_currency_id = ?', from_date, ledger_currency.id).group(:dh).sum(:represent_value), format_value)
+        process(children_moves.filter_date_start(from_date).where('represent_ledger_currency_id = ?', ledger_currency.id).group(:dh).sum(:represent_value), format_value)
+      end
+
+      #Saldo desde - hasta
+      define_method "balance_from_to_#{c}" do |format_value, from_date, to_date|
+        ledger_currency = get_currency(c.upcase)
+        process(children_moves.filter_date_start(from_date).filter_date_end(to_date).where('represent_ledger_currency_id = ?', ledger_currency.id).group(:dh).sum(:represent_value), format_value)
+      end
+
+    end
+
+
+
+
+    def process(dh_hash, format_value)
+      debe  = dh_hash["D"].to_i
+      haber = dh_hash["H"].to_i   
+      format_value ? LedgerMove.format_value(process_balance(debe, haber)) : process_balance(debe, haber)
+    end
+
+
+    def get_currency(c)
+      if c.nil?
+        c = SnapplerContable.default_currency
+      else
+        if c.is_a? Numeric
+          c = LedgerCurrency.find(c)
+        elsif c.is_a? String
+          c = LedgerCurrency.find_by_code(c)
+        end
+      end
+      return c
+    end
+
+
+    def children_moves
+      LedgerMove.where(ledger_account_id: child_ids+[self.id])
+    end
+
+    def process_balance
+      raise "Este metodo solo se tiene que implementar en las subclases"
+    end
+
+
+    def update_balance(value, dh, ledger_currency_id)
+      balance_update = case dh.upcase
+      when 'D' then process_balance(value, 0)  
+      when 'H' then process_balance(0, value)  
+      end
+
+      lc = LedgerCurrency.find(ledger_currency_id)
+
+
+      
+      currency = lc.code.downcase
+      self.send("balance_sum_#{currency}=", (self.send("balance_sum_#{currency}") + balance_update))
+      save
+    end
+
+  def update_balance_destroy(value, dh, ledger_currency_id)
+    #inverse operation
+    ops = {'D' => 'H', 'H' => 'D'}
+    update_balance(value, ops[dh], ledger_currency_id)
+  end
+                 
+
+end

data/app/models/ledger_account_activo.rb

@@ -0,0 +1,8 @@
+class LedgerAccountActivo < LedgerAccount
+
+	def process_balance(debe, haber) 
+		debe - haber
+	end
+end
+
+

data/app/models/ledger_account_pasivo.rb

@@ -0,0 +1,6 @@
+class LedgerAccountPasivo < LedgerAccount
+
+	def process_balance(debe, haber) 
+		haber - debe
+	end
+end

data/app/models/ledger_account_patrimonio_neto.rb

@@ -0,0 +1,6 @@
+class LedgerAccountPatrimonioNeto < LedgerAccount
+
+	def process_balance(debe, haber) 
+		haber - debe
+	end
+end

data/app/models/ledger_account_relation.rb

@@ -0,0 +1,8 @@
+class LedgerAccountRelation < ActiveRecord::Base
+
+  #--------------------------------------------- RELATIONS
+  belongs_to :ledger_account_father, class_name: "LedgerAccount"
+  belongs_to :ledger_account_child, class_name: "LedgerAccount"
+
+  
+end

data/app/models/ledger_account_resultado_negativo.rb

@@ -0,0 +1,6 @@
+class LedgerAccountResultadoNegativo < LedgerAccount
+
+	def process_balance(debe, haber) 
+		debe - haber
+	end  
+end

data/app/models/ledger_account_resultado_positivo.rb

@@ -0,0 +1,6 @@
+class LedgerAccountResultadoPositivo < LedgerAccount
+
+	def process_balance(debe, haber) 
+		haber - debe
+	end  
+end

data/app/models/ledger_currency.rb

@@ -0,0 +1,5 @@
+class LedgerCurrency < ActiveRecord::Base
+	def to_s
+		code
+	end
+end

data/app/models/ledger_entry.rb

@@ -0,0 +1,7 @@
+class LedgerEntry < ActiveRecord::Base
+
+  #--------------------------------------------- RELATIONS	
+  belongs_to :owner, polymorphic: true, optional: true
+  has_many :ledger_moves, dependent: :destroy
+
+end

data/app/models/ledger_move.rb

@@ -0,0 +1,76 @@
+class LedgerMove < ActiveRecord::Base
+
+  #--------------------------------------------- RELATIONS
+  belongs_to :ledger_entry
+  belongs_to :ledger_account
+  belongs_to :real_ledger_currency, class_name: 'LedgerCurrency'
+  belongs_to :represent_ledger_currency, class_name: 'LedgerCurrency'
+
+  #--------------------------------------------- CALLBACKS
+  after_create :update_balance_create
+  after_destroy :update_balance_destroy
+  after_update :update_balance_update
+
+  #--------------------------------------------- SCOPES
+  scope :filter_date_start, ->(date) { where('ledger_moves.datetime >= :datetime', datetime: Date.parse(date).beginning_of_day.to_datetime) if date.present? }
+  scope :filter_date_end, ->(date) { where('ledger_moves.datetime <= :datetime', datetime: Date.parse(date).end_of_day.to_datetime) if date.present? }
+  scope :order_date_asc, -> { order('ledger_moves.datetime ASC, ledger_moves.id ASC')}
+
+
+
+  #--------------------------------------------- METHODS
+  def update_balance_create
+    self.ledger_account.update_balance(raw_represent_value, dh, represent_ledger_currency_id)
+  end
+
+  def update_balance_destroy
+    self.ledger_account.update_balance_destroy(raw_represent_value, dh, represent_ledger_currency_id)
+  end  
+
+  def update_balance_update    
+    self.ledger_account.update_balance_destroy(represent_value_was, dh, represent_ledger_currency_id_was)
+    self.ledger_account.update_balance(raw_represent_value, dh, represent_ledger_currency_id)
+  end
+
+
+  def self.format_value(value)
+    value / SnapplerContable.default_divisor
+  end
+
+  def self.unformat_value(value)    
+    (value * SnapplerContable.default_divisor).round.to_i
+  end  
+
+
+
+  #Defino metodos para los 2 valores ("real_value", "represent_value")
+  ['real_value', 'represent_value'].each do |the_method|
+
+    #Getter
+    define_method "#{the_method}" do
+      value_formated = read_attribute the_method.to_sym
+      self.class.format_value(value_formated)
+    end
+
+    #Setter
+    define_method "#{the_method}=" do |val|
+      if val.is_a? Numeric
+        write_attribute the_method.to_sym, self.class.unformat_value(val)
+      else
+        raise "El valor debe ser un numero"
+      end
+    end
+
+    #Crudo Getter
+    define_method "raw_#{the_method}" do
+      return read_attribute the_method.to_sym
+    end
+
+  end
+
+
+
+
+
+end
+

data/lib/generators/snappler_contable/initializer_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators'  
+
+module SnapplerContable
+  class InitializerGenerator < ::Rails::Generators::Base
+    def create_initializer_file
+      create_file "config/initializers/snappler_contable.rb", "# Monedas usadas\nSnapplerContable.used_currencies = ['ARS','USD','EUR','BRL'] \#'JPY'\n\n# Moneda por defecto\nSnapplerContable.default_currency = 'ARS'\n\n# Divisor por defecto (2 decimales)\nSnapplerContable.default_divisor = 100.0"
+    end
+  end
+end
+
+

data/lib/generators/snappler_contable/migrate_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module SnapplerContable
+  class MigrateGenerator < ::Rails::Generators::Base
+    include Rails::Generators::Migration
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc "add snappler_contable migration"
+    def self.next_migration_number(path)
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+     @prev_migration_nr.to_s
+    end
+
+    def copy_migrations
+     migration_template "snappler_contable_migrate.rb", "db/migrate/snappler_contable_migrate.rb"
+     migration_template "snappler_contable_add_currencies.rb", "db/migrate/snappler_contable_add_currencies.rb"
+     migration_template "snappler_contable_app_ledger_accounts.rb", "db/migrate/snappler_contable_app_ledger_accounts.rb"
+    end
+  end
+end

data/lib/generators/snappler_contable/new_currency_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module SnapplerContable
+  class NewCurrencyGenerator < ::Rails::Generators::Base
+    include Rails::Generators::Migration
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc "add snappler_contable migration"
+    def self.next_migration_number(path)
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+     @prev_migration_nr.to_s
+    end
+
+    def copy_migrations
+     migration_template "snappler_contable_new_currency.rb", "db/migrate/snappler_contable_new_currency.rb"
+    end
+  end
+end