snappler_contable 0.1.0 → 1.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTk2MmZmNzQ2YThhMTgwMThjZDhmZjgxYWY3MzU1NzkwMWQ1YmI3ZQ==
+    YjEzYjJkMzE4ZjE2N2FlMWNkZmRiNmY5MGY2NDJkZmUxOTcyNDU2MQ==
   data.tar.gz: !binary |-
-    M2FmN2YyNzY1MDk5NWI2YjdmYjUxMDRmMWQ3OWQ5YWMxYTBkZDdhYw==
+    ZTUxMzdmYzM1MTVjYTVjYWQ2ZTc4MzcxZTAwY2ZhODc0YTQ3MDNjYQ==
 SHA512:
   metadata.gz: !binary |-
-    NGU2OTJiZmU2MzQ5NmVhN2NmMmJiMDJlYmU3MTVmZWI0ZjJhNjhmMDQ0MDQy
-    MjI3ODg0ZmIwMWFiY2FjNjBjNjBmYjgyMjMyYWQwOGIzZjk1Y2Y5NTJjOGQ1
-    NjBiMGU1ZWUyNzQ4NTI2YWViMTg1MGI2NjEzMTE5NGEwNmY2NzM=
+    YTc3M2NiYzA0YjI4OGQ1N2Q2ZGVmZDA0MzYwMjI1YmM5Nzk2YTA4ZjIzNjBj
+    NGM5MTI4MjNhMzViMTRjZGQ2ZGZkMThhZGE1YWJjYTM3NDkzYWQzZWEyMWNk
+    YTQ4YWVmYzBjMzk4MmU1ZDZmMWU1ODYxMmEyZmM5NWM2ZDc4ZDI=
   data.tar.gz: !binary |-
-    YTcyMTI1OWQ0MTI4NDdjY2QzNmQ0NjA1NzBiMTU1ODZjOGExNTVjYjE1MzY4
-    MjA0MmYxMDJlYzY3NTE1NzE4MzcwM2I3OTU0OTYwODI2NWRkYmE0OTNkNzlk
-    ZDY1MmM2Y2Y3NGY1NzVjNTdjZDQ5ZTE0NGM1ZGU0N2QxNGMzNDA=
+    M2QyZmRiNDE3YjUxZTRmN2E1NWUxYjc4MzZhYjEzNDIxMjE3NDc3ZWU1MzZi
+    Y2UzMWMzNzBiNDk4Zjk3MzMzM2IyODY2YjZhNzI0MDc0NzQyNGNkZTJlZTQ1
+    NDI4MjJjNmViYWFiYjJkOWRiNDU0ZTk5YTNjMjczNzM3NGIwYTQ=

data/README.rdoc

@@ -269,6 +269,8 @@ Devuelve el sub árbol de cuentas que baja desde la cuenta sobre la que se ejecu
 - objeto_act_as_snp_contable.ledger_accounts
 Devuelve un array con las cuentas contables (las crea si es necesario) vinculadas con el objeto.
 
+- objeto_act_as_snp_contable.get_ledger_account_by_code_name(:symbol)
+Devuelve la cuenta contable asocidada (las crea si es necesario) vinculadas con el objeto.
 
 = Operación contable
 
@@ -302,7 +304,32 @@ Por último, respecto a las operaciones, si dentro de alguno las colecciones de
 
 
 
-
+------------------------------------------------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------------------------------------------- v1.1
+FIXES
+    * El calculo ahora las operaciones se hacen en enteros Y DESPUES se transforman
+    * La funcion 'unformat_value(value)' de LedgerMove hace un round antes de tl .to_i, elimina el bug del flotante
+
+FEATURES / CHANGES
+    * Currencies ahora tiene un campo para el simbolo 'sym', ($, u$s, etc)
+    * Agregado monedas dolar y euro
+    * Ahora la gema es multicurrency funcional:
+        El método 'balance' ahora devuelve un hash {ID_CURRENCY => AMOUNT, ID_CURRENCY => AMOUNT}
+    * IMPORTANTE!!! El método 'SnapplerContable.op' en versiones viejas va a fallar, ya que en esta Version cambia como recive
+    los parámetros
+        Ejemplo:
+            Version Vieja: 
+                SnapplerContable.op(array_debe, array_haber, operation_debe = nil, operation_haber = nil)
+            
+            Version Actual: 
+                SnapplerContable.op(array_debe, array_haber, params_hash => {:operation_debe => nil, :operation_haber => nil, :date => nil})
+
+        Agregado el campo date a la operacion para buscar entre esa fecha y no con el 'created_at' de antes
 
 
 

data/app/models/ledger_account.rb

@@ -1,7 +1,8 @@
 class LedgerAccount < ActiveRecord::Base
   #--------------------------------------------- RELATIION
+  has_many :ledger_moves, :dependent => :destroy
   belongs_to :contable, polymorphic: true
-  has_many :child_ledger_accounts, :class_name => "LedgerAccount", :foreign_key => "master_ledger_account_id", :order => 'order_column'
+  has_many :child_ledger_accounts, :class_name => "LedgerAccount", :foreign_key => "master_ledger_account_id", :order => 'order_column', :dependent => :destroy
   belongs_to :master_ledger_account, :class_name => "LedgerAccount" 
   #--------------------------------------------- MISC
   attr_accessible :name, :code, :code_name, :master_ledger_account_id, :master_ledger_account, :contable, :balance_sum
@@ -11,10 +12,22 @@ class LedgerAccount < ActiveRecord::Base
   #--------------------------------------------- CALLBACK
   before_save :set_code
   after_create :set_order_column
+  #before_destroy :has_no_ledger_moves?
   #--------------------------------------------- SCOPES
   default_scope order('order_column ASC')
   #--------------------------------------------- METHODS
 
+  #Valida q no tenga operaciones de gasto relacionadas
+  def has_no_ledger_moves?
+    if self.ledger_moves.any?
+      self.errors[:base] << "No se pudo borrar porque tiene Movimientos asociados"
+      return false
+    else
+      return true
+    end
+  end
+
+
   def self.account(value)
     where(:code_name => value.to_s.snp_underscore).first
   end
@@ -30,6 +43,17 @@ class LedgerAccount < ActiveRecord::Base
     end
   end
 
+  def add_child_with_contable(name, code_name, contable)
+    if self.persisted?    
+      self.class.create(name: name, master_ledger_account: self, contable: contable, code_name: "#{code_name}_#{contable.class.name.underscore}_#{contable.id}"  )    
+    else
+      if self.errors.count > 0
+        errores = " La cuenta '#{name}' no se pudo persistir porque sus campos no cumplen la validacion de LedgerAccount."
+      end
+      raise "La instancia debe estar persistida para poder agregar una cuenta hija." + errores.to_s
+    end
+  end
+
   def set_code
     unless self.master_ledger_account_id == 0
       unless self.order_column.nil?
@@ -80,72 +104,155 @@ class LedgerAccount < ActiveRecord::Base
     balance
   end
 
-  def balance
-    bal = LedgerAccount.where(:id => children_accounts_ids).sum(:balance_sum)    
-    LedgerMove.format_value(bal)
+  #Mejora la logica
+  def special_balance(params)
+    from_date = params[:from_date]
+    to_date = params[:to_date]
+    format_value = (params[:format_value].nil?)? true : params[:format_value]
+    
+    if((from_date.nil?) && (to_date.nil?))
+      return balance(format_value)
+    else
+      if((! from_date.nil?) && (! to_date.nil?))
+        return balance_from_to(from_date, to_date, format_value)
+      else
+        if(! from_date.nil?)
+          return balance_from(from_date, format_value)
+        else
+          return balance_to(to_date, format_value)
+        end
+      end
+    end
+  end
+
+
+  def balance_zero?
+    hash_balance = self.balance
+    zero = true
+    LedgerCurrency.all.each{|x| zero &&= (hash_balance[x.id.to_s].nil?)||(hash_balance[x.id.to_s].zero?) }
+    return zero
+  end
+
+  def balance_zero_or_minor?
+    hash_balance = self.balance
+    zero = true
+    LedgerCurrency.all.each{|x| zero &&= (hash_balance[x.id.to_s].nil?)||(hash_balance[x.id.to_s] <= 0) }
+    return zero
+  end
+
+
+  def balance(format_value=true)
+    bal = {}
+    LedgerAccount.where(:id => children_accounts_ids).each do |account|
+      bal.merge!(eval(account.balance_sum)){|key, oldval, newval| newval + oldval} if(! account.balance_sum.blank?)
+    end
+
+    #Proceso la info para mostrarla en flotante
+    bal.reject!{|x,y| y.zero?}
+    bal.each{|x,y|  bal[x] = LedgerMove::format_value(y) } if(format_value)
+    bal_sorted = {}
+    bal.sort.collect{|elem| bal_sorted[elem.first] = elem.last }
+    return bal_sorted
   end
 
 
-  def balance_to(to_date)
-    dh_hash = LedgerMove.where(:ledger_account_id => children_accounts_ids).where('created_at <= ?', to_date.end_of_day).group(:dh).sum(:value)
-    debe = dh_hash["D"].to_i
-    haber = dh_hash["H"].to_i   
-    LedgerMove.format_value(process_balance(debe, haber))
+  def balance_to(to_date, format_value=true)
+    bal_debe = {}
+    bal_haber = {}
+    LedgerCurrency.all.each{|x| bal_debe[x.id] = 0; bal_haber[x.id] = 0}
+    bal = {}
+
+    dh_array = LedgerMove.where(:ledger_account_id => children_accounts_ids).where('date <= ?', to_date)
+    dh_array.each do |dh|
+      bal_debe.merge!({dh.ledger_currency_id => dh.raw_value}){|key, oldval, newval| newval + oldval} if(dh.dh == 'D')
+      bal_haber.merge!({dh.ledger_currency_id => dh.raw_value}){|key, oldval, newval| newval + oldval} if(dh.dh == 'H')
+    end
+
+    bal = process_balance(bal_debe, bal_haber)
+    bal.reject!{|x,y| y.zero?}
+    bal.each{|x,y|  bal[x] = LedgerMove::format_value(y) } if(format_value)
+
+    bal_sorted = {}
+    bal.sort.collect{|elem| bal_sorted[elem.first] = elem.last }
+    return bal_sorted
   end
 
-  def balance_from(from_date)
-    dh_hash = LedgerMove.where(:ledger_account_id => children_accounts_ids).where('created_at >= ?', from_date.beginning_of_day).group(:dh).sum(:value)
-    debe = dh_hash["D"].to_i
-    haber = dh_hash["H"].to_i   
-    LedgerMove.format_value(process_balance(debe, haber))
+  def balance_from(from_date, format_value=true)
+    bal_debe = {}
+    bal_haber = {}
+    LedgerCurrency.all.each{|x| bal_debe[x.id] = 0; bal_haber[x.id] = 0}
+    bal = {}
+
+    dh_array = LedgerMove.where(:ledger_account_id => children_accounts_ids).where('date >= ?', from_date)
+    dh_array.each do |dh|
+      bal_debe.merge!({dh.ledger_currency_id => dh.raw_value}){|key, oldval, newval| newval + oldval} if(dh.dh == 'D')
+      bal_haber.merge!({dh.ledger_currency_id => dh.raw_value}){|key, oldval, newval| newval + oldval} if(dh.dh == 'H')
+    end
+
+    bal = process_balance(bal_debe, bal_haber)
+    bal.reject!{|x,y| y.zero?}
+    bal.each{|x,y|  bal[x] = LedgerMove::format_value(y) } if(format_value)
+
+    bal_sorted = {}
+    bal.sort.collect{|elem| bal_sorted[elem.first] = elem.last }
+    return bal_sorted
   end  
 
-  def balance_from_to(from_date, to_date)
-    dh_hash = LedgerMove.where(:ledger_account_id => children_accounts_ids).where('created_at >= ? AND created_at <= ?', from_date.beginning_of_day, to_date.end_of_day).group(:dh).sum(:value)
-    debe = dh_hash["D"].to_i
-    haber = dh_hash["H"].to_i   
-    LedgerMove.format_value(process_balance(debe, haber))
+  def balance_from_to(from_date, to_date, format_value=true)
+    bal_debe = {}
+    bal_haber = {}
+    LedgerCurrency.all.each{|x| bal_debe[x.id] = 0; bal_haber[x.id] = 0}
+    bal = {}
+
+    dh_array = LedgerMove.where(:ledger_account_id => children_accounts_ids).where('date >= ? AND date <= ?', from_date, to_date)
+    dh_array.each do |dh|
+      bal_debe.merge!({dh.ledger_currency_id => dh.raw_value}){|key, oldval, newval| newval + oldval} if(dh.dh == 'D')
+      bal_haber.merge!({dh.ledger_currency_id => dh.raw_value}){|key, oldval, newval| newval + oldval} if(dh.dh == 'H')
+    end
+    bal = process_balance(bal_debe, bal_haber)
+    bal.reject!{|x,y| y.zero?}
+    bal.each{|x,y|  bal[x] = LedgerMove::format_value(y) } if(format_value)
+
+    bal_sorted = {}
+    bal.sort.collect{|elem| bal_sorted[elem.first] = elem.last }
+    return bal_sorted
   end    
 
+
+
   def process_balance
     raise "Este metodo solo se tiene que implementar en las subclases"
   end
 
-  def update_balance(value, dh)
+  def update_balance(value, dh, ledger_currency)
     case dh.upcase
     when 'D'
-      update_balance = process_balance(value, 0)  
+      update_balance = process_balance({ledger_currency.id.to_s => value}, {ledger_currency.id.to_s => 0})  
     when 'H'
-      update_balance = process_balance(0, value)  
-    end   
-    bal = self.balance_sum
-    self.balance_sum = bal + update_balance
-    save
+      update_balance = process_balance({ledger_currency.id.to_s => 0}, {ledger_currency.id.to_s => value})  
+    end
+
+    #Obtengo el Hash
+    balance_sum = (self.balance_sum.blank?)? {} : eval(self.balance_sum)
+    bal = (balance_sum[ledger_currency.id.to_s].nil?)? 0 : balance_sum[ledger_currency.id.to_s]
+    balance_sum[ledger_currency.id.to_s] =  (update_balance[ledger_currency.id.to_s] + bal)
+
+    #Elimino las q son zero asi no queda basura
+    balance_sum.reject!{|x,y| y.zero?}
+    self.balance_sum = balance_sum.to_s
+    self.save
   end
 
-  def update_balance_destroy(value, dh)
+  def update_balance_destroy(value, dh, ledger_currency)
     #inverse operation
     ops = {'D' => 'H', 'H' => 'D'}
-    update_balance(value, ops[dh])
+    update_balance(value, ops[dh], ledger_currency)
   end
 
   def accounts_tree
     SnapplerContable.account_sub_tree(self)
   end                     
 
-  def balance_sum=(val)
-    if val.is_a? Numeric
-      write_attribute :balance_sum, LedgerMove.unformat_value(val)
-    else
-      raise "El valor debe ser un numero"
-    end
-  end
-
-  def balance_sum
-    value_formated = read_attribute :balance_sum
-    LedgerMove.format_value(value_formated)
-  end 
-
 end
 
 

data/app/models/ledger_account_activo.rb

@@ -1,6 +1,8 @@
 class LedgerAccountActivo < LedgerAccount
 
 	def process_balance(debe, haber) 
-		debe - haber
+		haber.merge(debe){|key, oldval, newval| newval - oldval}
 	end
 end
+
+

data/app/models/ledger_account_pasivo.rb

@@ -1,6 +1,6 @@
 class LedgerAccountPasivo < LedgerAccount
 
 	def process_balance(debe, haber) 
-		haber - debe
+		debe.merge(haber){|key, oldval, newval| newval - oldval}
 	end
 end

data/app/models/ledger_account_patrimonio_neto.rb

@@ -1,6 +1,6 @@
 class LedgerAccountPatrimonioNeto < LedgerAccount
 
 	def process_balance(debe, haber) 
-		haber - debe
+		debe.merge(haber){|key, oldval, newval| newval - oldval}
 	end
 end

data/app/models/ledger_account_resultado_negativo.rb

@@ -1,6 +1,6 @@
 class LedgerAccountResultadoNegativo < LedgerAccount
 
 	def process_balance(debe, haber) 
-		debe - haber
+		haber.merge(debe){|key, oldval, newval| newval - oldval}
 	end  
 end

data/app/models/ledger_account_resultado_positivo.rb

@@ -1,6 +1,6 @@
 class LedgerAccountResultadoPositivo < LedgerAccount
 
 	def process_balance(debe, haber) 
-		haber - debe
+		debe.merge(haber){|key, oldval, newval| newval - oldval}
 	end  
 end

data/app/models/ledger_currency.rb

@@ -1,3 +1,3 @@
 class LedgerCurrency < ActiveRecord::Base
-  attr_accessible :code, :name
+  attr_accessible :code, :name, :sym
 end

data/app/models/ledger_move.rb

@@ -4,8 +4,8 @@ class LedgerMove < ActiveRecord::Base
   belongs_to :ledger_account
   belongs_to :ledger_currency  
   #--------------------------------------------- MISC
-  attr_accessible :currency_ratio, :dh, :value, :ledger_account, :ledger_currency, :currency_ratio
-  DIVISOR = 100.0  
+  attr_accessible :currency_ratio, :dh, :value, :ledger_account, :ledger_currency, :currency_ratio, :date
+  DIVISOR = 100.0
   #--------------------------------------------- VALIDATION
 
   #--------------------------------------------- CALLBACK
@@ -14,29 +14,60 @@ class LedgerMove < ActiveRecord::Base
   after_update :update_balance_update
 
   #--------------------------------------------- SCOPES
+  scope :filter_date_start, lambda { |date| if((date)&&(! date.blank?))
+    {:conditions => ["ledger_moves.date >= ?", Date.parse(date)]}
+  end }
+
+  scope :filter_date_end, lambda { |date| if((date)&&(! date.blank?))
+    {:conditions => ["ledger_moves.date <= ?", Date.parse(date)]}
+  end }
+
+  scope :order_date_asc, :order => 'ledger_moves.date ASC, ledger_moves.id ASC'
 
   #--------------------------------------------- METHODS  
 
   def update_balance_create
-    self.ledger_account.update_balance(value, dh)
+    self.ledger_account(true).update_balance(raw_value, dh, ledger_currency)
   end
 
+
   def update_balance_destroy
-    self.ledger_account.update_balance_destroy(value, dh)
+    self.ledger_account(true).update_balance_destroy(raw_value, dh, ledger_currency)
   end  
 
+
   def update_balance_update    
-    self.ledger_account.update_balance_destroy( self.class.format_value(value_was), dh)
-    self.ledger_account.update_balance(value, dh)
+    self.ledger_account(true).update_balance_destroy(value_was, dh, ledger_currency)
+    self.ledger_account(true).update_balance(raw_value, dh, ledger_currency)
   end
 
+  def self.format_hash(bal)
+    bal_aux = {}
+    bal.each{|x,y|  bal_aux[x] = LedgerMove::format_value(y) }
+
+    bal_sorted = {}
+    bal_aux.sort.collect{|elem| bal_sorted[elem.first] = elem.last }
+
+    return bal_sorted
+  end
+
+  def self.unformat_hash(bal)
+    bal_aux = {}  
+    bal.each{|x,y|  bal_aux[x] = LedgerMove::unformat_value(y) }
+    
+    bal_sorted = {}
+    bal_aux.sort.collect{|elem| bal_sorted[elem.first] = elem.last }
+    
+    return bal_sorted
+  end  
+
 
   def self.format_value(value)
     value / DIVISOR
   end
 
   def self.unformat_value(value)    
-    (value * DIVISOR).to_i
+    (value * DIVISOR).round.to_i
   end  
 
   def value=(val)
@@ -47,8 +78,23 @@ class LedgerMove < ActiveRecord::Base
     end
   end
 
+  def currency_with_value(format_value=true)
+    case self.dh.upcase
+    when 'D'
+      bal = self.ledger_account.process_balance({self.ledger_currency_id.to_s => self.raw_value}, {ledger_currency.id.to_s => 0})
+    when 'H'
+      bal = self.ledger_account.process_balance({ledger_currency.id.to_s => 0}, {self.ledger_currency_id.to_s => self.raw_value})
+    end
+    bal = LedgerMove::format_hash(bal) if(format_value)
+    return bal
+  end
+
   def value
     value_formated = read_attribute :value
     self.class.format_value(value_formated)
   end
+
+  def raw_value
+    return read_attribute :value
+  end
 end

data/lib/generators/snappler_contable/templates/snappler_contable_migrate.rb

@@ -1,8 +1,9 @@
+# -*- coding: utf-8 -*-
 class SnapplerContableMigrate < ActiveRecord::Migration
   def self.up
     create_table :ledger_accounts do |t|
       t.string :name
-      t.integer :balance_sum, :default => 0
+      t.string :balance_sum
       t.string :code
       t.string :code_name
       t.integer :order_column
@@ -28,6 +29,7 @@ class SnapplerContableMigrate < ActiveRecord::Migration
       t.integer :value, :default => 0
       t.references :ledger_currency
       t.float :currency_ratio
+      t.date :date
 
       t.timestamps
     end
@@ -42,10 +44,12 @@ class SnapplerContableMigrate < ActiveRecord::Migration
     create_table :ledger_currencies do |t|
       t.string :name
       t.string :code
-
+      t.string :sym
       t.timestamps
     end    
-    LedgerCurrency.create(name: 'Peso', code: 'ARS')
+    LedgerCurrency.create(name: 'Peso', code: 'ARS', sym: '$')
+    LedgerCurrency.create(name: 'Dolar', code: 'DOL', sym: 'u$s')
+    LedgerCurrency.create(name: 'Euro', code: 'EUR', sym: '€')
   end
 
   def self.down

data/lib/snappler_contable/snappler_contable.rb

@@ -78,7 +78,10 @@ module SnapplerContable
     return res_accounts
   end
 
-  def self.op(array_debe, array_haber, operation_debe = nil, operation_haber = nil)
+  def self.op(array_debe, array_haber, params_hash)
+    operation_debe = params_hash[:operation_debe]
+    operation_haber = params_hash[:operation_haber]
+    date = params_hash[:date]
 
     if operation_haber.nil?
       operation_haber = operation_debe
@@ -117,7 +120,7 @@ module SnapplerContable
         m[:currency] = dc
         m[:currency_ratio] = 1
       end
-      le.ledger_moves.build(ledger_account: m[:account], value: m[:value], dh: m[:dh], ledger_currency: m[:currency], currency_ratio: m[:currency_ratio])
+      le.ledger_moves.build(ledger_account: m[:account], value: m[:value], dh: m[:dh], ledger_currency: m[:currency], currency_ratio: m[:currency_ratio], date: date)
     end
 
     if le.save

data/lib/snappler_contable/version.rb

@@ -1,3 +1,3 @@
 module SnapplerContable
-  VERSION = "0.1.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: snappler_contable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Juan La Battaglia