snappler_contable 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTk2MmZmNzQ2YThhMTgwMThjZDhmZjgxYWY3MzU1NzkwMWQ1YmI3ZQ==
+  data.tar.gz: !binary |-
+    M2FmN2YyNzY1MDk5NWI2YjdmYjUxMDRmMWQ3OWQ5YWMxYTBkZDdhYw==
+SHA512:
+  metadata.gz: !binary |-
+    NGU2OTJiZmU2MzQ5NmVhN2NmMmJiMDJlYmU3MTVmZWI0ZjJhNjhmMDQ0MDQy
+    MjI3ODg0ZmIwMWFiY2FjNjBjNjBmYjgyMjMyYWQwOGIzZjk1Y2Y5NTJjOGQ1
+    NjBiMGU1ZWUyNzQ4NTI2YWViMTg1MGI2NjEzMTE5NGEwNmY2NzM=
+  data.tar.gz: !binary |-
+    YTcyMTI1OWQ0MTI4NDdjY2QzNmQ0NjA1NzBiMTU1ODZjOGExNTVjYjE1MzY4
+    MjA0MmYxMDJlYzY3NTE1NzE4MzcwM2I3OTU0OTYwODI2NWRkYmE0OTNkNzlk
+    ZDY1MmM2Y2Y3NGY1NzVjNTdjZDQ5ZTE0NGM1ZGU0N2QxNGMzNDA=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,315 @@
+= SnapplerContable
+
+Esta gema agrega a una aplicacion la capacidad de manejar cuentas contables con el modelo teorico economico.
+
+== Instalacion
+
+Agregar esta linea al Gemfile
+
+    gem "snappler_contable"
+
+Ejecutar
+
+    $ bundle install
+
+Después de instalar se deben correr estos comandos
+
+    $ rails g snappler_contable:initializer
+    $ rails g snappler_contable:migrate
+    $ rake db:migrate  
+
+Esto va a crear el achivo:
+
+    config/initializers/snappler_contable.rb
+
+Donde se tienen que agregar todas las operaciones contables se van a ejecutar en el sistema.
+
+Tambien va a crear dos migraciones:
+
+    aaaammdd_snappler_contable_migrate.rb
+
+Que crea la tabla de cuentas, de movimientos, de asientos y de monedas.
+Se crean 5 registros en la tabla LedgerAccounts que son necesarios para el sistema:
+
+    LedgerAccountActivo : Activo
+    LedgerAccountPasivo : Pasivo
+    LedgerAccountPatrimonioNeto : Patrimonio Neto
+    LedgerAccountResultadoPositivo : Resultado Positivo
+    LedgerAccountResultadoNegativo : Resultado Negativo
+
+Tambien crea la moneda por defecto:
+    LedgerCurrency.create(name: 'Peso', code: 'ARS')
+
+Luego crea otra migración llamada:
+
+    aaaammdd_snappler_contable_app_ledger_accounts.rb
+
+En la que el programador debe agregar las cuentas necesarias para el plan de cuentas de la aplicacion.
+Ya están cargadas en variables de instancia las 5 cuentas originales.
+Luego se usa el metodo 'add_child' para agregar cuentas hijas.
+
+    activo = LedgerAccountActivo.first #en ese momento solo existe una
+    sub_cuenta_activo = activo.add_child('Sub cuenta activo')
+
+Esta función se puede usar en cualquier parte de la applicación.
+La cuenta hija será de la misma clase que la clase padre.
+
+== Uso
+
+La gema va a trabajar con:
+	
+1) Una estructura de tipo árbol de objetos. Cada objeto es una instancia de una de las 5 sub clases de LedgerAccount.
+El árbol tiene una raiz abstracta y 5 nodos:
+	
+    LedgerAccountActivo : Activo
+    LedgerAccountPasivo : Pasivo
+    LedgerAccountPatrimonioNeto : Patrimonio Neto
+    LedgerAccountResultadoPositivo : Resultado Positivo
+    LedgerAccountResultadoNegativo : Resultado Negativo	
+
+Luego se agregaran las cuentas que completen el plan de cuentas específico para la aplicación.
+Una vez creadas las cuentas del plan, quedaría (por ejemplo) así:
+	
+ => ROOT
+     1 : Activo (1)
+         1.1 : Disponibilidades (2)
+             1.1.1 : Caja (3)
+             1.1.2 : Bancos (4)
+                 1.1.2.1 : Cuenta Corriente (5)
+                 1.1.2.2 : Caja de Ahorro (6)
+         1.2 : Cuentas x cobrar (7)
+         1.3 : Bienes de cambio (8)
+         1.4 : Bienes de uso (9)
+             1.4.1 : Rodados (10)
+     2 : Pasivo (11)
+         2.1 : Proveedores (12)
+         2.2 : Banco pasivo (13)
+             2.2.1 : Prestamo (14)
+     3 : Patrimonio Neto (15)
+         3.1 : Capital Social (16)
+     4 : Resultado Positivo (17)
+         4.1 : Ventas (18)
+         4.2 : Diferencia de Stock (19)
+         4.3 : Arqueo (20)
+             4.3.1 : Arqueo banco (21)
+             4.3.2 : Arqueo caja (22)
+     5 : Resultado Negativo (23)
+         5.1 : Costo mercaderia vendida (24)
+         5.2 : Diferencia de Stock negativo (25)
+         5.3 : Arqueo negativo (26)
+             5.3.1 : Arqueo negativo banco (27)
+             5.3.2 : Arqueo negativo caja (28)
+
+(NOTA: el número entre paréntesis es el id del objeto)
+
+2) Un archivo de tipo 'initializer':
+	/config/initializers/snappler_contable.rb
+	
+# Agregar el array de operaciones validas
+SnapplerContable.valid_operations = [:cobro, :pago, :deposito]
+
+	Operaciones válidas para ejecutar con la gema. Las operaciones válidas son aquellas necesarias para vincular un modelo normal de la aplicacion con una cuenta subclase de LedgerAccount.
+
+# Moneda por defecto
+SnapplerContable.default_currency = 'ARS'
+	Moneda usada por la gema por defecto. En particular setea 'ARS'. Para modificarla hay que crear la moneda que se desea y poner el códigod de la nueva moneda. Si se cambia se tiene que reiniciar la aplicación.
+
+	
+3) Modelos comunes de la aplicación, los cuales se pueden vincular con una o mas cuentas del plan de cuentas existente.
+
+Un modelo (hijo de ActiveRecord) puede vincularse al plan de cuentas mediante la sentencia:
+	
+	class Product < ActiveRecord::Base
+  	  ...
+  	  
+	  act_as_snappler_contable(	:accounts => [:bienes_de_cambio, :cuentas_x_cobrar], 
+					:account_by_operation => {:pago => :bienes_de_cambio,
+								:cobro => :cuentas_x_cobrar}) 
+	  ...
+	end
+
+En este caso la clase Product está vinculada con la cuenta :bienes_de_cambio y :cuentas_x_cobrar
+Esto significa que las instancias de la clase Product crearán cuentas de la misma clase que :bienes_de_cambio y :cuentas_x_cobrar, y serán hijas de la cuenta respectiva.
+
+El array :accounts contiene todas las cuentas con las que estará vinculada la clase Product.
+El array :account_by_operation indica cual la cuenta padre con la que se vinculará, en función la operación que se pase por parámetro al momento de ejecutar un movimiento contable.
+
+Esto significa que cuando se ejecute un movimiento contable con operación :pago que involucre a un objeto de tipo Product, por ejemplo "Harina", se agregará una nueva cuenta, hija de :bienes_de_pago, vinculada con el producto "Harina". El plan de cuentas quedará así:
+
+ => ROOT
+     1 : Activo (1)
+         1.1 : Disponibilidades (2)
+             1.1.1 : Caja (3)
+             1.1.2 : Bancos (4)
+                 1.1.2.1 : Cuenta Corriente (5)
+                 1.1.2.2 : Caja de Ahorro (6)
+         1.2 : Cuentas x cobrar (7)
+         1.3 : Bienes de cambio (8)
+             1.3.1 : Bienes De Cambio Product:Harina (40)
+     ...
+
+Existe la posibilidad que haya modelos relacionados entre sí que tengan que vincularse con el plan de cuentas.
+Un ejemplo podría ser la cuenta Bancos se va a relacionar con Objetos de tipo banco de la aplicación, y a su vez estos bancos tendran cajas de ahorro que, logicamente, tienen que estar integradas al plan de cuentas.
+
+
+Plan de cuentas
+ => ROOT
+     1 : Activo (1)
+         1.1 : Disponibilidades (2)
+             1.1.1 : Caja (3)
+             1.1.2 : Bancos (4)
+
+Modelos del sistema:
+ Bank
+   BankAccount
+
+
+La única relación permitida de 'belongs_to'.
+
+En este caso los modelos quedarían así:
+	
+	class Bank < ActiveRecord::Base
+	  act_as_snappler_contable(:accounts => [:bancos], 
+				:account_by_operation => {}) 
+	  ...
+	end
+
+	class BankAccount < Account
+	  belongs_to :bank  
+	  act_as_snappler_contable(:accounts => [{:bancos => :bank}], 
+                           :account_by_operation => {:deposito => :bancos, :extraccion => :bancos, :transferencia => :bancos})     
+	end	
+
+Como se ve, en la clase BankAccount, en el parametro :accounts se indica un hash:
+	
+	{:bancos => :bank}
+
+Esto significa que BanckAccount está en la rama de la cuenta contable :bancos a través del la relación "belongs_to :bank"
+
+Entonces tendríamos una clase "inmediata" a las cuentas contables (en este caso Bank), que en su parametro :accounts indica su cuenta contable padre (:bancos), y luego clases que cuelgan de la "inmediata" (BankAccount) que en el parametro :accounts tienen que indicar cual es la cuenta contable superior, y a través de qué relación la alcanza (:bank, ya que tiene declarado un "belongs_to :bank").
+
+Las clases hacia "abajo" no tienen límite, siempre y cuando indiquen cual es la cuenta contable superior.
+El ejemplo ya no tiene significado real, pero supongamos que la cuenta puede tener una sub-cuenta, en este caso la clase se vería así:
+	
+	class SubBankAccount < Account
+	  belongs_to :bank_account
+	  act_as_snappler_contable(:accounts => [{:bancos => :bank_account}], 
+                           :account_by_operation => {:deposito => :bancos, :extraccion => :bancos, :transferencia => :bancos})     
+	end
+
+De esta forma, una vez ejecutada una operación contable que involucre estos objetos, el plan de cuentas se vería así:
+
+ => ROOT
+     1 : Activo (1)
+         1.1 : Disponibilidades (2)
+             1.1.1 : Caja (3)
+             1.1.2 : Bancos (4)
+                 1.1.2.1 : Cuenta Corriente (5)
+                 1.1.2.2 : Caja de Ahorro (6)
+                 1.1.2.3 : Bancos Bank:Patagonia (41)
+                     1.1.2.3.1 : Bancos Bank:Patagonia BankAccount:Cc Banco Patagonia (42)
+                         1.1.2.3.1.1 : Bancos Bank:Patagonia BankAccount:Cc Banco Patagonia SubBankAccount:Sub Cc Banco Patagonia (45)
+
+
+== Funciones del módulo SnapplerContable
+
+Para operar con la gema, algunas de las operaciones se ejecutan directamente como métodos de clase de SnapplerContable.
+
+- SnapplerContable.accounts_tree
+Devuelve el plan de cuentas como un árbol.
+Se imprime indentando y con el código de plan de cuentas.
+El arbol implementa "each", de esa forma se puede tratar con las operaciones de coleccion conocidas.
+
+	SnapplerContable.accounts_tree.each {|a| puts a.code}
+
+
+- SnapplerContable.re_code_tree
+Si se llega a cambiar el código de alguna de la cuentas de la raiz, o se cambia el valor el campo 'order' se debe ejecutar el método
+
+	SnapplerContable.re_code_tree
+
+De esta forma todos los códigos se reacomodarán.
+
+== Funciones del modelo de cuentas contables (subclases de LedgerAccount)
+
+- cuenta.balance 
+Devuelve el saldo para la cuenta.
+Usa el campo 'balance_sum' que se actualiza en cada LedgerAccount a medida que se agregan movimientos LedgerMoves.
+Cada cuenta tiene su saldo actualizado.
+Para devolverlo se consulta por los saldos de todas las cuentas hijas.
+
+- cuenta.balance_to(to_date)
+Da el saldo calculando con los movimientos hasta  la fecha 'to_date'
+
+- cuenta.balance_from(from_date)
+Da el saldo calculando con los movimientos desde  la fecha 'from_date'
+
+- cuenta.balance_from(from_date)
+Da el saldo calculando con los movimientos desde  la fecha 'from_date' hasta  la fecha 'to_date'
+
+Las funciones de saldo con fecha usan la tabla LedgerMoves de esta forma:
+Hace el cálculo del saldo de la cuenta, teniendo en cuenta los movimientos vinculados con dicha cuenta y con todas las cuentas de su sub árbol.
+El cálculo del saldo va a depender de la clase de la cuenta:
+
+    LedgerAccountActivo : debe - haber
+    LedgerAccountPasivo : haber - debe
+    LedgerAccountPatrimonioNeto : haber - debe
+    LedgerAccountResultadoPositivo : haber - debe
+    LedgerAccountResultadoNegativo : debe - haber
+
+las operacioes cuenta.balance y cuenta.balance_to(fecha del ultimo movimiento registrado) tienen que dar lo mismo.
+
+
+
+- cuenta.accounts_tree
+Devuelve el sub árbol de cuentas que baja desde la cuenta sobre la que se ejecuta el comando
+
+== Funciones agregadas por act_as_snappler_contable
+
+- objeto_act_as_snp_contable.ledger_accounts
+Devuelve un array con las cuentas contables (las crea si es necesario) vinculadas con el objeto.
+
+
+= Operación contable
+
+- SnapplerContable.op
+Es la operación que registra los movimientos para la cuentas.
+
+El formato es:
+	
+	SnapplerContable.op(Colección movimientos debe, Colección movimientos haber, operación debe, operación haber )
+
+Las colecciones de movimientos debe/haber tiene un formato análogo.
+
+Colección movimientos debe/haber:
+	[{account: LedgerAccount u objeto de clase act_as_snappler_contable,
+	  value: valor,
+	  order: orden del movimiento (opcional) (solo funciona si TODOS los movimientos tienen order),
+	  currency: id (integer) u objeto LedgerCurrency (opcional, ARS por defecto),
+	  currency_ratio: cotización de la moneda (opcional, 1 por defecto),
+	  operation: operacion para extraer cuenta contable, en caso de que account: sea objeto de clase act_as_snappler_contable (opcional) }]
+
+La suma de los values de "Colección movimientos debe" y "Colección movimientos haber" deben ser iguales.
+
+En caso de que en el parámetro 'account:' de alguno de los movimientos sea un objeto act_as_snappler_contable, se debe especificar la operación que extrae la cuenta contable correspondiente.
+Hay que tomarla del parametro ':account_by_operation' del act_as_snappler_contable.
+
+Si el objeto está la "Colección movimientos debe" o "Colección movimientos haber", la operación se pasa como tercer parámetro.
+En caso de que haya objetos en "Coleccion movimientos debe" y "Colección movimientos haber" que deban extraerse con operaciones distintas, se pasan dos parámetros más, siendo el primero usado para la colección del debe y el segudo para el haber.
+
+Por último, respecto a las operaciones, si dentro de alguno las colecciones de movivientos hay objetos de los que se deben extraer cuentas con operaciones distintas, el hash de movimiento soporta el parámetro :operation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+	

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SnapplerContable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/models/ledger_account.rb

@@ -0,0 +1,151 @@
+class LedgerAccount < ActiveRecord::Base
+  #--------------------------------------------- RELATIION
+  belongs_to :contable, polymorphic: true
+  has_many :child_ledger_accounts, :class_name => "LedgerAccount", :foreign_key => "master_ledger_account_id", :order => 'order_column'
+  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
+  #--------------------------------------------- VALIDATION
+  validates :master_ledger_account_id, :presence => true
+  validates :code_name, :uniqueness => true
+  #--------------------------------------------- CALLBACK
+  before_save :set_code
+  after_create :set_order_column
+  #--------------------------------------------- SCOPES
+  default_scope order('order_column ASC')
+  #--------------------------------------------- METHODS
+
+  def self.account(value)
+    where(:code_name => value.to_s.snp_underscore).first
+  end
+
+  def add_child(name)
+    if self.persisted?    
+      self.class.create(name: name, master_ledger_account: self )    
+    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?
+        self.code = "#{self.master_ledger_account.code}.#{self.order_column}"
+      end
+    end
+  end
+
+  def re_code(parent_code)
+    self.code = "#{parent_code}#{parent_code.blank? ? '' : '.'}#{order_column}"
+    save
+    child_ledger_accounts.each do |child|
+      child.re_code(code)
+    end
+  end  
+
+  def name=(value)
+    write_attribute :name, value
+    if (read_attribute(:code_name)).blank?
+      name_value = read_attribute(:name)
+      write_attribute :code_name, name_value.snp_underscore
+    end    
+  end
+
+  def set_order_column
+    #Solo agrega orden si la cuenta no es tope del arbol
+    unless self.master_ledger_account_id == 0
+      max = self.master_ledger_account.child_ledger_accounts.maximum(:order_column)
+    else
+      max = LedgerAccount.where(:master_ledger_account_id => 0).maximum(:order_column)
+    end
+
+    if max.nil?
+      self.order_column = 1
+    else
+      self.order_column = max + 1
+    end
+
+    self.save
+  end
+
+  def children_accounts_ids
+    SnapplerContable.account_sub_tree(self).collect{|account| account.id}
+  end
+
+  def saldo
+    #alias para compatibilidad
+    balance
+  end
+
+  def balance
+    bal = LedgerAccount.where(:id => children_accounts_ids).sum(:balance_sum)    
+    LedgerMove.format_value(bal)
+  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))
+  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))
+  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))
+  end    
+
+  def process_balance
+    raise "Este metodo solo se tiene que implementar en las subclases"
+  end
+
+  def update_balance(value, dh)
+    case dh.upcase
+    when 'D'
+      update_balance = process_balance(value, 0)  
+    when 'H'
+      update_balance = process_balance(0, value)  
+    end   
+    bal = self.balance_sum
+    self.balance_sum = bal + update_balance
+    save
+  end
+
+  def update_balance_destroy(value, dh)
+    #inverse operation
+    ops = {'D' => 'H', 'H' => 'D'}
+    update_balance(value, ops[dh])
+  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

@@ -0,0 +1,6 @@
+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_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,3 @@
+class LedgerCurrency < ActiveRecord::Base
+  attr_accessible :code, :name
+end

data/app/models/ledger_entry.rb

@@ -0,0 +1,3 @@
+class LedgerEntry < ActiveRecord::Base
+  has_many :ledger_moves, :dependent => :destroy
+end

data/app/models/ledger_move.rb

@@ -0,0 +1,54 @@
+class LedgerMove < ActiveRecord::Base
+  #--------------------------------------------- RELATION
+  belongs_to :ledger_entry
+  belongs_to :ledger_account
+  belongs_to :ledger_currency  
+  #--------------------------------------------- MISC
+  attr_accessible :currency_ratio, :dh, :value, :ledger_account, :ledger_currency, :currency_ratio
+  DIVISOR = 100.0  
+  #--------------------------------------------- VALIDATION
+
+  #--------------------------------------------- CALLBACK
+  after_create :update_balance_create
+  after_destroy :update_balance_destroy
+  after_update :update_balance_update
+
+  #--------------------------------------------- SCOPES
+
+  #--------------------------------------------- METHODS  
+
+  def update_balance_create
+    self.ledger_account.update_balance(value, dh)
+  end
+
+  def update_balance_destroy
+    self.ledger_account.update_balance_destroy(value, dh)
+  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)
+  end
+
+
+  def self.format_value(value)
+    value / DIVISOR
+  end
+
+  def self.unformat_value(value)    
+    (value * DIVISOR).to_i
+  end  
+
+  def value=(val)
+    if val.is_a? Numeric
+      write_attribute :value, self.class.unformat_value(val)
+    else
+      raise "El valor debe ser un numero"
+    end
+  end
+
+  def value
+    value_formated = read_attribute :value
+    self.class.format_value(value_formated)
+  end
+end

data/lib/generators/snappler_contable/initializer_generator.rb

@@ -0,0 +1,9 @@
+require 'rails/generators'  
+
+module SnapplerContable
+  class InitializerGenerator < ::Rails::Generators::Base
+    def create_initializer_file
+      create_file "config/initializers/snappler_contable.rb", "# Agregar el array de operaciones validas\nSnapplerContable.valid_operations = [:pago]\n\n# Moneda por defecto\nSnapplerContable.default_currency = 'ARS'"
+    end
+  end
+end

data/lib/generators/snappler_contable/migrate_generator.rb

@@ -0,0 +1,24 @@
+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_app_ledger_accounts.rb", "db/migrate/snappler_contable_app_ledger_accounts.rb"
+    end
+  end
+end