snappler_contable 0.1.0

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

@@ -0,0 +1,17 @@
+class SnapplerContableAppLedgerAccounts < ActiveRecord::Migration
+  def self.up
+    activo = LedgerAccountActivo.first
+    # sub_cuenta_activo_1 = activo.add_child("Sub Cuenta Activo 1")
+    # sub_cuenta_activo_2 = activo.add_child("Sub Cuenta Activo 2")
+    #   sub_sub_cuenta_activo = sub_cuenta_activo_2.add_child("Sub Sub Cuenta Activo 1")
+
+    pasivo = LedgerAccountPasivo.first
+    patrimonio_neto = LedgerAccountPatrimonioNeto.first
+    resultado_positivo = LedgerAccountResultadoPositivo.first
+    resultado_negativo = LedgerAccountResultadoNegativo.first
+  end
+
+  def self.down
+    LedgerAccount.destroy_all("master_ledger_account_id <> 0")
+  end
+end

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

@@ -0,0 +1,57 @@
+class SnapplerContableMigrate < ActiveRecord::Migration
+  def self.up
+    create_table :ledger_accounts do |t|
+      t.string :name
+      t.integer :balance_sum, :default => 0
+      t.string :code
+      t.string :code_name
+      t.integer :order_column
+      t.references :contable, :polymorphic => true
+      t.integer :master_ledger_account_id
+      t.string :type
+
+      t.timestamps
+    end
+    add_index :ledger_accounts, :contable_id
+
+    #Las primeras 5 deben existir
+    aa = LedgerAccountActivo.create(name: 'Activo', code: '1', master_ledger_account_id: '0')
+    ap = LedgerAccountPasivo.create(name: 'Pasivo', code: '2', master_ledger_account_id: '0')
+    apn = LedgerAccountPatrimonioNeto.create(name: 'Patrimonio Neto', code: '3', master_ledger_account_id: '0')
+    arp = LedgerAccountResultadoPositivo.create(name: 'Resultado Positivo', code: '4', master_ledger_account_id: '0')
+    arn = LedgerAccountResultadoNegativo.create(name: 'Resultado Negativo', code: '5', master_ledger_account_id: '0')
+
+    create_table :ledger_moves do |t|
+      t.references :ledger_entry
+      t.references :ledger_account
+      t.string :dh, :limit => 1
+      t.integer :value, :default => 0
+      t.references :ledger_currency
+      t.float :currency_ratio
+
+      t.timestamps
+    end
+    add_index :ledger_moves, :ledger_entry_id
+    add_index :ledger_moves, :ledger_account_id
+    add_index :ledger_moves, :ledger_currency_id
+
+    create_table :ledger_entries do |t|
+      t.timestamps
+    end
+
+    create_table :ledger_currencies do |t|
+      t.string :name
+      t.string :code
+
+      t.timestamps
+    end    
+    LedgerCurrency.create(name: 'Peso', code: 'ARS')
+  end
+
+  def self.down
+    drop_table :ledger_accounts
+    drop_table :ledger_moves
+    drop_table :ledger_entries
+    drop_table :ledger_currencies
+  end
+end

data/lib/snappler_contable/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def snp_underscore
+    self.underscore.gsub(' ', '_')
+  end
+end

data/lib/snappler_contable/railtie.rb

@@ -0,0 +1,4 @@
+module SnapplerContable
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/snappler_contable/snappler_contable.rb

@@ -0,0 +1,131 @@
+
+module SnapplerContable
+
+  def self.default_currency=(default_currency)
+      @my_default_currrency = default_currency
+  end
+
+  def self.default_currency
+    #@my_default_currrency
+    LedgerCurrency.find_by_code(@my_default_currrency)
+  end
+
+  def self.valid_operations=(operations)
+    @my_valid_operations = operations
+  end
+
+
+  def self.valid_operations
+    @my_valid_operations
+  end
+
+
+  def self.accounts_tree
+    tree = TreeNode.new(nil, true)
+    tree.add_child_ledger_accounts(LedgerAccount.where(:master_ledger_account_id => 0))
+    return tree
+  end
+
+  def self.account_sub_tree(ledger_account)
+    tree = TreeNode.new(nil, true)
+    tree.add_child_ledger_accounts([ledger_account])
+    return tree
+  end
+
+  def self.re_code_tree
+    LedgerAccount.where(:master_ledger_account_id => 0).each do |account|
+      account.re_code('')
+    end
+  end
+
+  def self.extract_accounts(moves_array, operation, debe_haber)
+
+    res_accounts = []
+    moves_array.each do |move|
+      move[:dh] = debe_haber
+      if move.key? :account
+        acc = move[:account]
+        if (acc.class.to_s == 'LedgerAccount') or (acc.class.superclass.to_s == 'LedgerAccount')
+          res_accounts << move
+        else
+          if move.key? :operation
+            oper = move[:operation]
+          else
+            oper = operation
+          end
+          if oper.nil?
+            raise "No se puede extraer la cuenta del objeto #{acc.class.to_s} con operation == nil"
+          else
+            unless acc.nil?
+              if acc.respond_to? "get_ledger_account_by_operation"
+                move[:account] = acc.get_ledger_account_by_operation(oper)
+                res_accounts << move
+              else
+                raise "La clase #{acc.class.to_s} no implementa el modulo contable."
+              end
+            else
+              raise "Se paso como cuenta un objeto Nil"
+            end
+          end
+        end
+      else
+        raise "El hash de movimiento no tiene :account - #{move}"
+      end
+      unless move.key? :value
+        raise "El hash de movimiento no tiene :value - #{move}"
+      end
+    end
+    return res_accounts
+  end
+
+  def self.op(array_debe, array_haber, operation_debe = nil, operation_haber = nil)
+
+    if operation_haber.nil?
+      operation_haber = operation_debe
+    end
+
+    #TODO Verificar si viene el mismo objeto en el debe y el haber y pedir DOS operaciones
+    debe_accounts = extract_accounts(array_debe, operation_debe, 'D')
+    haber_accounts = extract_accounts(array_haber, operation_haber, 'H')
+
+    total_debe = debe_accounts.inject(0){|init, move| init + move[:value] }
+    total_haber = haber_accounts.inject(0){|init, move| init + move[:value] }
+
+    if total_haber != total_debe
+      raise "Las sumas del DEBE y HABER son diferentes - debe: #{total_debe} haber: #{total_haber}"
+    end
+
+    all_moves = debe_accounts + haber_accounts
+
+    #verificando si todos los movimientos tienen orden
+    if all_moves.inject(true){|res, move| res & (move.key? :order)}
+      all_moves.sort!{|a, b| a[:order] <=> b[:order]}
+    end
+
+    dc = SnapplerContable.default_currency
+
+    le = LedgerEntry.create
+    all_moves.each do |m|
+      if m.key? :currency
+        if m[:currency].is_a? Numeric
+          m[:currency] = LedgerCurrency.find(m[:currency])
+        end
+        unless m.key? :currency_ratio
+          m[:currency_ratio] = 1
+        end
+      else
+        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])
+    end
+
+    if le.save
+      le
+    else
+      le.destroy
+      raise "Fallo la creacion del movimiento: #{all_moves}"
+    end
+  end
+
+end

data/lib/snappler_contable/snappler_contable_active_record_extension.rb

@@ -0,0 +1,172 @@
+module SnapplerContable
+  module SnapplerContableActiveRecordExtension
+
+
+    def self.included(base)  
+      base.extend ClassMethods  
+    end  
+
+    # add your static(class) methods here
+    module ClassMethods
+      #act_as_snappler_contable(:accounts => [:acc_1, :acc_2],
+      #               :account_by_operation => {:oper_1 => :acc_1, :oper_2 => :acc_2})
+      #                                         
+      def act_as_snappler_contable(config_hash = nil)
+        if config_hash.nil? or config_hash.class.to_s != "Hash"
+          raise "\nError en la declaracion de act_as_snappler_contable en la clase #{name}\nUso de act_as_snappler_contable:\n      #act_as_snappler_contable(:accounts => [:acc_1, :acc_2],\n      #               :account_by_operation => {:oper_1 => :acc_1,\n      #                                         :oper_2 => :acc_2})\n"
+        end
+
+        if config_hash.key? :accounts
+
+          ledger_account_aux = config_hash[:accounts]
+          @my_ledger_accounts = {}
+          ledger_account_aux.each do |account| 
+            #si es hash, esta relacionado con otro objeto
+            if account.is_a? Hash 
+              account.each_pair do |key, value| 
+                @my_ledger_accounts[key] = value unless @my_ledger_accounts.key? key
+              end
+            else
+              @my_ledger_accounts[account] = nil unless @my_ledger_accounts.key? account
+            end
+          end
+
+          @my_ledger_accounts.each_key do |code_name|
+
+            if LedgerAccount.find_by_code_name(code_name.to_s.snp_underscore).nil?
+              raise "La cuenta '#{code_name}' (code_name: '#{code_name.to_s.snp_underscore}') no existe como cuenta contable LedgerAccount"
+            end
+
+          end          
+        else
+          raise "La clase '#{self.class}' no declara cuentas en 'act_as_snappler_contable{:accounts => []}'"
+        end
+
+        if config_hash.key? :account_by_operation
+          @my_op_account_hash = config_hash[:account_by_operation]
+          #chequea que todas las operaciones existan
+          valid_ops = SnapplerContable.valid_operations
+          @my_op_account_hash.each_pair do |oper, acc|
+            unless valid_ops.include? oper
+              raise "La clase #{self.name} declara la operacion ':#{oper}', que no existe como operacion valida en 'config/initializers/snappler_contable.rb'"
+            end
+            unless @my_ledger_accounts.include? acc
+              raise "La clase #{self.name} indica: ':#{oper} => :#{acc}', pero la cuenta '#{acc}' no esta incluida en 'act_as_snappler_contable{:accounts => []}'"
+            end
+          end          
+        else
+          raise "La clase '#{self.class}' no declara cuenta por operacion en 'act_as_snappler_contable{:account_by_operation => []}'"
+        end
+
+        #Definicion de metodos
+
+        define_method(:get_parent_belongs_to) do |ledger_account_code_name|
+          parent_belongs_to = self.class.get_my_ledger_accounts[ledger_account_code_name]
+
+          unless parent_belongs_to.nil?
+            unless self.respond_to? parent_belongs_to
+              raise "No existe la relacion 'belongs_to :#{parent_belongs_to}' en la clase #{self.class}"
+            end
+
+            if eval("self.#{parent_belongs_to.to_s}").nil?
+              raise "El objeto de la relacion belongs_to :#{parent_belongs_to} es nil. Class #{self.class} belongs_to :#{parent_belongs_to} - id: #{self.id}"
+            end        
+
+            parent_object = eval("self.#{parent_belongs_to.to_s}")
+
+            return parent_belongs_to, parent_object
+
+          else
+            return nil, nil
+          end
+        end    
+
+        define_method(:get_name_and_code_name) do |ledger_account_code_name|
+
+          parent_belongs_to, parent_object = get_parent_belongs_to(ledger_account_code_name)
+          if parent_belongs_to.nil?
+
+            name_aux = ledger_account_code_name.to_s.titleize + " "
+            code_name_aux = name_aux
+          else
+
+            parent_object_account = parent_object.get_ledger_account_by_code_name(ledger_account_code_name)
+            parent_name_aux, parent_code_name_aux = parent_object.get_name_and_code_name(ledger_account_code_name)
+            name_aux = parent_name_aux + " "
+            code_name_aux = parent_code_name_aux + " "
+          end
+          name_aux += self.class.to_s
+          name_aux += ":"
+
+          #TODO configuracion del campo "name" para que pueda tomar otro campo para nombre
+          name_aux += (self.respond_to?(:name)) ? self.name.to_s.titleize : self.id.to_s
+          code_name_aux += "#{self.class.to_s} #{self.id.to_s}"
+          code_name_aux = code_name_aux.snp_underscore
+          return name_aux, code_name_aux
+        end      
+
+
+        define_method(:get_ledger_account_by_operation) do |operation|
+          if SnapplerContable.valid_operations.include? operation
+            ledger_account_code_name = self.class.get_my_accounts_by_operation[operation]
+            if ledger_account_code_name.blank?
+              raise "La operacion ':#{operation.to_s}' no esta incluida como :account_by_operation en la sentencia 'act_as_snappler_contable' de la clase #{self.class.to_s.titleize}"
+            else
+              return get_ledger_account_by_code_name(ledger_account_code_name)
+            end
+          else
+            raise "La operacion ':#{operation.to_s}' no esta incluida como valid_operation en 'config/initializers/snappler_contable.rb'"
+          end
+        end 
+
+        define_method(:get_ledger_account_by_code_name) do |ledger_account_code_name|
+          if self.class.get_my_ledger_accounts.include? ledger_account_code_name
+            if self.persisted?
+              name_aux, code_name_aux = get_name_and_code_name(ledger_account_code_name)
+              res_ledger_account = LedgerAccount.find_by_code_name(code_name_aux)
+              if res_ledger_account.nil?
+                #no existe la cuenta relacionada, se crea
+                #verifica que no este en relacion belongs_to
+                parent_belongs_to, parent_object = get_parent_belongs_to(ledger_account_code_name)
+                if parent_belongs_to.nil?
+                  master_ledger_account = LedgerAccount.find_by_code_name(ledger_account_code_name.to_s)
+                else
+                  master_ledger_account = parent_object.get_ledger_account_by_code_name(ledger_account_code_name)
+                end
+                if not master_ledger_account.nil?
+                  #uso la clase del padre para crear la cuenta de objeto
+                  res_ledger_account = master_ledger_account.class.create(name: name_aux, code_name: code_name_aux, master_ledger_account: master_ledger_account, contable: self )
+                  return res_ledger_account
+                else
+                  raise  "No existe la cuenta padre #{ledger_account_code_name.to_s}"
+                end
+              else
+                #se devuelve la cuenta relacionada
+                return res_ledger_account
+              end
+            else
+              raise "El objeto de clase #{self.class} aun no esta persistido, no tiene cuenta #{ledger_account_code_name.to_s} asociada"
+            end
+          else
+            raise "La clase '#{self.class.to_s.titleize}' no esta vinculada a la cuenta #{ledger_account_code_name.to_s}"
+          end
+        end
+
+        define_method(:ledger_accounts) do          
+          res = self.class.get_my_ledger_accounts.map{|a| a.first}          
+          res.map{|acc_code_name| get_ledger_account_by_code_name(acc_code_name)}
+        end 
+      end
+
+      def get_my_accounts_by_operation
+        @my_op_account_hash
+      end    
+
+      def get_my_ledger_accounts
+        @my_ledger_accounts
+      end
+
+    end
+
+  end
+end

data/lib/snappler_contable/tree_node.rb

@@ -0,0 +1,47 @@
+module SnapplerContable
+  class TreeNode
+
+    include Enumerable
+
+    attr_accessor :object, :childrens, :root
+
+    def initialize(account, root=false)
+      if root
+        @object = 'ROOT'
+      else
+        @object = account
+      end
+      @childrens = []
+      @root = root
+    end
+
+    def add_child_ledger_accounts(accounts)
+      accounts.each do |account|
+        node = TreeNode.new(account)
+        childrens << node
+        node.add_child_ledger_accounts(account.child_ledger_accounts)
+      end
+    end
+
+    def name
+      root ? 'ROOT' : "#{object.code} : #{object.name} (#{object.id})"
+    end
+
+    def to_s(indent=0)
+      res = (' ' * indent) + "#{name}\n"
+      res = res + @childrens.map{ |child| " " + child.to_s(indent + 4)}.join("\n")
+      res.gsub("\n\n", "\n")
+    end
+
+    def each(&block)
+      unless root
+        block.call object
+      end
+      childrens.each do |child|
+        child.each(&block)
+      end
+      self
+    end  
+
+  end
+end

data/lib/snappler_contable/version.rb

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

data/lib/snappler_contable.rb

@@ -0,0 +1,19 @@
+require "snappler_contable/ext/string"
+require "snappler_contable/snappler_contable_active_record_extension"
+require "snappler_contable/snappler_contable"
+require "snappler_contable/tree_node"
+
+module SnapplerContable
+
+  # To setup run $ rails generate snappler_contable:install
+  def self.setup
+    yield self
+  end
+
+  class ActiveRecord::Base  
+    include SnapplerContableActiveRecordExtension
+  end
+  
+end
+
+require 'snappler_contable/railtie' if defined?(Rails)

data/lib/tasks/snappler_contable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :snappler_contable do
+#   # Task goes here
+# end