colppy 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 423516e6c9f241cf1d2e7ddaa3dc32bacf8ed356
-  data.tar.gz: ccb895a2d95fa3f55b3f2a97f7b0c21743d5c182
+  metadata.gz: 56924725187f03b328b0305020b7acee209863df
+  data.tar.gz: d22d27f9c912065931f93142177e2ce38eb6b3fc
 SHA512:
-  metadata.gz: 59f62eb828dd05967ff21e9d567c39cc8830bd2f3820f9bd331b7f0ae27cc5c0a20d4745c92d82d339c434188b08b330a31e84ab60e8d1a741ed9d34acde72c2
-  data.tar.gz: 07f3ee5c00ac9e8a79630911765013709fe07fffb1095dc99e8587b6fa0d2d07c8330cef152db5aa2963e7fa32c369257baf9e7a180b541710be4fe1c4ffb208
+  metadata.gz: 474bfe2dbb9a742e729752bad31a3aa99c240529bb9c86d5a956f3e6159cc21c3a9e7ed1de8f7d7f575e6429fd4928aa6809c76e592844713a754287ee387742
+  data.tar.gz: 823a5176e7bc75a6dc83f0d2e9eaff0227e1399f08be15408a40898fa430f1bb3e5ddc1e006fdc48e5e3763125241c4fe5d446b6eea266452e79fad3355f4596

data/README.md

@@ -1,5 +1,6 @@
-#Colppy
-[![Build Status](https://travis-ci.org/goodpeople/colppy.svg?branch=master)](https://travis-ci.org/goodpeople/colppy)
+# Colppy [![Build Status](https://travis-ci.org/goodpeople/colppy.svg?branch=master)](https://travis-ci.org/goodpeople/colppy)
+
+> **Still unstable version and prone to change here and there ;)**
 
 ## Installation
 

data/lib/colppy.rb

@@ -4,6 +4,7 @@ require 'multi_json'
 
 require "colppy/version"
 require "colppy/digest"
+require "colppy/utils"
 # CORE
 require "colppy/core/services"
 require "colppy/core/gateway"
@@ -11,6 +12,7 @@ require "colppy/core/gateway"
 require "colppy/resource"
 require "colppy/resources/customer"
 require "colppy/resources/company"
+require "colppy/resources/invoice"
 require "colppy/resources/product"
 require "colppy/resources/sell_invoice"
 require "colppy/resources/user"

data/lib/colppy/core/services.rb

@@ -29,6 +29,12 @@ module Colppy
           operacion: "editar_cliente"
         }
       },
+      inventory: {
+        accounts_list: {
+          provision: "Inventario",
+          operacion: "listar_cuentasAsentables"
+        }
+      },
       product: {
         list: {
           provision: "Inventario",

data/lib/colppy/resource.rb

@@ -1,6 +1,7 @@
 module Colppy
   class Resource
-    VALID_INVOICE_TYPES = %w(A B C E Z I M X)
+    attr_reader :data
+    include Utils
 
     class << self
       protected
@@ -28,6 +29,14 @@ module Colppy
       end
     end
 
+    def initialize(params)
+      @data = rename_params_hash(
+        params,
+        self.class::ATTRIBUTES_MAPPER,
+        self.class::DATA_KEYS_SETTERS
+      )
+    end
+
     def inspect
       formatted_attrs = attr_inspect.map do |attr|
         "#{attr}: #{send(attr).inspect}"
@@ -35,6 +44,20 @@ module Colppy
       "#<#{self.class.name} #{formatted_attrs.join(", ")}>"
     end
 
+    def []=(key, value)
+      key_sym = key.to_sym
+      if PROTECTED_DATA_KEYS.include?(key_sym)
+        raise ResourceError.new("You cannot change any of this values: #{PROTECTED_DATA_KEYS.join(", ")} manually")
+      end
+      if DATA_KEYS_SETTERS.include?[key]
+        @data[key_sym] = value
+      elsif new_key = ATTRIBUTES_MAPPER[key_sym]
+        @data[new_key] = value if DATA_KEYS_SETTERS.include?(new_key)
+      else
+        raise DataError.new("There is no attribute named :#{key_sym}, or you cannot change it manually this way. Try initializing another #{self.class.name} with that attribute as the argument")
+      end
+    end
+
     private
 
     def attr_inspect
@@ -78,6 +101,5 @@ module Colppy
         )
       end
     end
-
   end
 end

data/lib/colppy/resources/company.rb

@@ -11,6 +11,13 @@ module Colppy
   class Company < Resource
     attr_reader :id, :name
 
+    ATTRIBUTES_MAPPER = {
+      idPlan: :plan_id,
+      activa: :active,
+      fechaVencimiento: :expiration_date
+    }.freeze
+    PROTECTED_DATA_KEYS = ATTRIBUTES_MAPPER.values
+
     class << self
       def all(client)
         list(client)
@@ -35,9 +42,10 @@ module Colppy
 
     def initialize(client: nil, **params)
       @client = client if client && client.is_a?(Colppy::Client)
-      @id = params.delete(:IdEmpresa)
-      @name = params.delete(:razonSocial)
-      @extras = params
+
+      @id = params.delete(:IdEmpresa) || params.delete(:id)
+      @name = params.delete(:razonSocial) || params.delete(:name)
+      super(params)
     end
 
     def customers(params = {})
@@ -49,12 +57,12 @@ module Colppy
         Customer.list(@client, self, params)
       end
     end
-
     def customer_by_id(id)
       ensure_client_valid!
 
       Customer.get(@client, self, id)
     end
+    alias :customer :customer_by_id
 
     def products(params = {})
       ensure_client_valid!
@@ -65,20 +73,17 @@ module Colppy
         Product.list(@client, self, params)
       end
     end
-    alias :customer :customer_by_id
-
-    def product_by_sku(sku)
+    def product_by_code(code)
       ensure_client_valid!
 
       params = {
         filter: [
-          { field: "codigo", op: "=", value: sku }
+          { field: "codigo", op: "=", value: code }
         ]
       }
       response = Product.list(@client, self, params)
       response[:results].last
     end
-
     def product_by_id(id)
       ensure_client_valid!
 
@@ -101,7 +106,6 @@ module Colppy
         SellInvoice.list(@client, self, params)
       end
     end
-
     def sell_invoice_by_id(id)
       ensure_client_valid!
 
@@ -109,6 +113,33 @@ module Colppy
     end
     alias :sell_invoice :sell_invoice_by_id
 
+    def available_accounts
+      return @available_accounts unless @available_accounts.nil? || @available_accounts.empty?
+
+      response = @client.call(
+        :inventory,
+        :accounts_list,
+        params.merge(@client.session_params)
+      )
+      if response[:success]
+        @available_accounts = response[:cuentas].map do |account|
+          {
+            id: account[:Id],
+            account_id: account[:idPlanCuenta],
+            full_name: account[:Descripcion],
+            name: account[:Descripcion].split(' - ')[1]
+          }
+        end
+      end
+    end
+    def account_name(account_id)
+      return if available_accounts.nil? || available_accounts.empty?
+
+      if account = available_accounts.detect{ |a| a[:account_id].to_s == account_id.to_s }
+        account[:name]
+      end
+    end
+
     def params
       { idEmpresa: @id }
     end

data/lib/colppy/resources/customer.rb

@@ -1,6 +1,36 @@
 module Colppy
   class Customer < Resource
-    attr_reader :id, :name, :data
+    attr_reader :id, :name
+
+    ATTRIBUTES_MAPPER = {
+      RazonSocial: :name,
+      NombreFantasia: :fantasy_name,
+      DirPostal: :address,
+      DirPostalCiudad: :address_city,
+      DirPostalCodigoPostal: :address_zipcode,
+      DirPostalProvincia: :address_state,
+      DirPostalPais: :address_country,
+      DirFiscal: :legal_address,
+      DirFiscalCiudad: :legal_address_city,
+      DirFiscalCodigoPostal: :legal_address_zipcode,
+      DirFiscalProvincia: :legal_address_state,
+      DirFiscalPais: :legal_address_country,
+      Telefono: :phone_number,
+      Fax: :fax_number,
+      Activo: :active,
+      idCondicionPago: :payment_condition_id,
+      idCondicionIva: :tax_condition_id,
+      CUIT: :cuit,
+      idTipoPercepcion: :tax_perception_id,
+      NroCuenta: :account_number,
+      CBU: :cbu,
+      Banco: :bank,
+      porcentajeIVA: :tax,
+      Email: :email,
+      Saldo: :balance
+    }.freeze
+    PROTECTED_DATA_KEYS = [:id, :company_id, :name].freeze
+    DATA_KEYS_SETTERS = (ATTRIBUTES_MAPPER.values - PROTECTED_DATA_KEYS).freeze
 
     class << self
       def all(client, company)
@@ -55,15 +85,20 @@ module Colppy
           }]
         }
       end
-
     end
 
     def initialize(client: nil, company: nil, **params)
       @client = client if client && client.is_a?(Colppy::Client)
       @company = company if company && company.is_a?(Colppy::Company)
-      @id = params.delete(:idCliente)
-      @name = params.delete(:RazonSocial)
-      @data = params
+
+      @id = params.delete(:idCliente) || params.delete(:id)
+      @name = params.delete(:RazonSocial) || params.delete(:name)
+      super(params)
+    end
+    DATA_KEYS_SETTERS.each do |data_key|
+      define_method("#{data_key}=") do |value|
+        @data[data_key.to_sym] = value
+      end
     end
 
     def new?
@@ -96,24 +131,12 @@ module Colppy
       @name = new_name
     end
 
-    def []=(key, value)
-      key_sym = key.to_sym
-      if protected_data_keys.include?(key_sym)
-        raise ResourceError.new("You cannot change any of this values: #{protected_data_keys.join(", ")} manually")
-      end
-      @data[key_sym] = value
-    end
-
     private
 
     def attr_inspect
       [:id, :name]
     end
 
-    def protected_data_keys
-      [:idUsuario, :idCliente, :idEmpresa]
-    end
-
     def operation
       new? ? :create : :update
     end

data/lib/colppy/resources/invoice.rb

@@ -0,0 +1,287 @@
+module Colppy
+  class Invoice < Resource
+    VALID_PAYMENT_CONDITIONS = ["Contado", "a 15 Dias", "a 30 Dias", "a 60 Dias"]
+    VALID_STATUS_ID = [ "Borrador", "Aprobada", "Anulada", "Cobrada" ]
+    VALID_INVOICE_TYPES = %w(A B C E Z I M X)
+
+    def add_item(params)
+      if item = Item.new(params, @company)
+        @items << item
+      end
+    end
+    def remove_item(key, value)
+      @items.delete_if do |item|
+        item.send(key.to_sym).to_s == value.to_s
+      end
+    end
+
+    def add_payment(params)
+      if payment = Payment.new(params)
+        @payments << payment
+      end
+    end
+
+    private
+
+    def parse_items(new_items)
+      return [] if new_items.nil? || new_items.empty?
+
+      new_items.map do |item_data|
+        Item.new(item_data, @company)
+      end
+    end
+
+    def parse_payments(new_payments)
+      return [] if new_payments.nil? || new_payments.empty?
+
+      new_payments.map do |payment_data|
+        Payment.new(payment_data)
+      end
+    end
+
+    def parse_taxes_totals(new_taxes_totals)
+      return [] if new_taxes_totals.nil? || new_taxes_totals.empty?
+
+      new_taxes_totals.map do |tax_total_data|
+        TaxTotal.new(tax_total_data)
+      end
+    end
+
+    def invoice_status
+      type = @data[:idEstadoFactura]
+      if type && VALID_INVOICE_STATUS.include?(type)
+        type
+      else
+        raise DataError.new("The value of idEstadoFactura=#{type} is invalid. The value should be any of this ones: #{VALID_INVOICE_STATUS.join(", ")}")
+      end
+    end
+
+    def invoice_type
+      type = @data[:idTipoFactura]
+      if type && VALID_INVOICE_TYPES.include?(type)
+        type
+      else
+        raise DataError.new("The idTipoFactura=#{type} is invalid. The value should be any of this ones: #{VALID_INVOICE_TYPES.join(", ")}")
+      end
+    end
+  end
+
+  class Invoice::Item
+    attr_reader :id, :data
+    include Utils
+
+    ATTRIBUTES_MAPPER = {
+      idItem: :product_id,
+      minimo: :minimum_stock,
+      tipoItem: :item_type,
+      codigo: :codigo,
+      Descripcion: :name,
+      unidadMedida: :measure_unit,
+      Cantidad: :quantity, # required
+      ImporteUnitario: :unit_price,
+      IVA: :tax,
+      subtotal: :subtotal,
+      idPlanCuenta: :sales_account_id,
+      Comentario: :comment
+    }.freeze
+    PROTECTED_DATA_KEYS = [:product_id].freeze
+    DATA_KEYS_SETTERS = (ATTRIBUTES_MAPPER.values - PROTECTED_DATA_KEYS).freeze
+
+    def initialize(params, company = nil)
+      @company = company if company.is_a?(Colppy::Company)
+
+      @id = params.delete(:id)
+      @product = params.delete(:product)
+      @data = rename_params_hash(params, ATTRIBUTES_MAPPER, DATA_KEYS_SETTERS)
+
+      if @product && @product.is_a?(Colppy::Product)
+        @data[:product_id] = @product.id
+      else
+        @product = nil
+      end
+    end
+
+    DATA_KEYS_SETTERS.each do |data_key|
+      define_method("#{data_key}") do
+        @data[data_key.to_sym]
+      end
+      define_method("#{data_key}=") do |value|
+        @data[data_key.to_sym] = value
+      end
+    end
+
+    def unhandle_data
+      @data[:unhandle] || {}
+    end
+
+    def product
+      @product ||= @company.product(@data[:product_id])
+    end
+
+    def product_id=(value)
+      @product = nil
+      @data[:product_id] = value
+    end
+    def product_id
+      @data[:product_id]
+    end
+
+    def tax
+      (@data[:tax] || product.tax || 0).to_f
+    end
+    def charged
+      (unit_price || product.sell_price || 0).to_f
+    end
+    def quantity
+      @data[:quantity] || 0
+    end
+    def total_charged
+      ( charged * quantity ).round(2)
+    end
+    def minimum_stock
+      (@data[:minimum_stock] || product.minimum_stock || 0)
+    end
+    def item_type
+      (@data[:item_type] || product.item_type || "P")
+    end
+    def code
+      (@data[:code] || product.code || "")
+    end
+    def name
+      (@data[:name] || product.name || "")
+    end
+    def measure_unit
+      (@data[:measure_unit] || product.measure_unit || "u")
+    end
+    def sales_account_id
+      (@data[:sales_account_id] || product.sales_account || "")
+    end
+    def comment
+      (@data[:comment] || "#{product.name}, #{product.detail}"  || "")
+    end
+
+    def save_parameters
+      {
+        idItem: product_id.to_s,
+        minimo: minimum_stock.to_s,
+        tipoItem: item_type,
+        codigo: code,
+        Descripcion: name,
+        ccosto1: unhandle_data[:ccosto1] || "",
+        ccosto2: unhandle_data[:ccosto2] || "",
+        almacen: unhandle_data[:almacen] || "",
+        unidadMedida: measure_unit,
+        Cantidad: quantity,
+        ImporteUnitario: charged,
+        porcDesc: unhandle_data[:porcDesc] || 0,
+        IVA: tax.to_s,
+        subtotal: total_charged,
+        idPlanCuenta: sales_account_id,
+        Comentario: comment
+      }
+    end
+
+    def inspect; end
+  end
+  class Invoice::Payment
+    include Utils
+
+    VALID_PAYMENT_TYPES = [
+      "Cheque Recibido Común",
+      "Cheque Recibido Diferido",
+      "Transferencia",
+      "Efectivo",
+      "Tarjeta de Credito"
+    ]
+
+    ATTRIBUTES_MAPPER = {
+      idMedioCobro: :payment_type_id, # required
+      idPlanCuenta: :payment_account_id, # required
+      Banco: :bank,
+      nroCheque: :check_number,
+      fechaValidez: :valid_date,
+      importe: :amount, # required
+      VAD: :vad,
+      Conciliado: :conciliated,
+      idTabla: :table_id,
+      idElemento: :element_id,
+      idItem: :item_id
+    }.freeze
+    DATA_KEYS_SETTERS = ATTRIBUTES_MAPPER.values
+
+    def initialize(params)
+      @data = rename_params_hash(params, ATTRIBUTES_MAPPER, DATA_KEYS_SETTERS)
+    end
+    DATA_KEYS_SETTERS.each do |data_key|
+      define_method("#{data_key}=") do |value|
+        @data[data_key.to_sym] = value
+      end
+    end
+
+    def amount
+      @data[:amount] || 0.0
+    end
+
+    def save_parameters
+      {
+        idMedioCobro: @data[:payment_type_id],
+        idPlanCuenta: @data[:payment_account_id],
+        Banco: @data[:bank] || "",
+        nroCheque: @data[:check_number] || "",
+        fechaValidez: @data[:valid_date] || "",
+        importe: amount,
+        VAD: @data[:vad] || "S",
+        Conciliado: @data[:conciliated] || "",
+        idTabla: @data[:table_id] || 0,
+        idElemento: @data[:element_id] || 0,
+        idItem: @data[:item_id] || 0
+      }
+    end
+
+    def inspect; end
+  end
+  class Invoice::TaxTotal
+    include Utils
+
+    def self.add_to_tax_breakdown(tax, amount, taxed_amount, breakdown = nil)
+      breakdown = breakdown || { tax_factor: tax, tax_amount: 0.0, taxed_amount: 0.0 }
+      breakdown[:tax_amount] += amount
+      breakdown[:taxed_amount] += taxed_amount
+      breakdown
+    end
+
+    ATTRIBUTES_MAPPER = {
+      alicuotaIva: :tax_factor,
+      importeIva: :tax_amount,
+      baseImpIva: :taxed_amount
+    }.freeze
+    DATA_KEYS_SETTERS = ATTRIBUTES_MAPPER.values
+
+    def initialize(params)
+      @data = rename_params_hash(params, ATTRIBUTES_MAPPER, DATA_KEYS_SETTERS)
+    end
+    DATA_KEYS_SETTERS.each do |data_key|
+      define_method("#{data_key}=") do |value|
+        @data[data_key.to_sym] = value
+      end
+    end
+
+    def tax_name
+      if @data[:tax_factor] % 1 == 0
+        @data[:tax_factor].to_i.to_s
+      else
+        @data[:tax_factor].to_s
+      end
+    end
+
+    def save_parameters
+      {
+        alicuotaIva: tax_name,
+        importeIva: @data[:tax_amount],
+        baseImpIva: @data[:taxed_amount]
+      }
+    end
+
+    def inspect; end
+  end
+end

data/lib/colppy/resources/product.rb

@@ -1,6 +1,26 @@
 module Colppy
   class Product < Resource
-    attr_reader :id, :name, :sku, :data
+    attr_reader :id, :name, :code
+
+    ATTRIBUTES_MAPPER = {
+      idItem: :id,
+      idEmpresa: :company_id,
+      codigo: :code,
+      descripcion: :name,
+      detalle: :detail,
+      precioVenta: :sell_price,
+      ultimoPrecioCompra: :last_purchase_price,
+      ctaInventario: :inventory_account,
+      ctaCostoVentas: :sales_costs_account,
+      ctaIngresoVentas: :sales_account,
+      iva: :tax,
+      tipoItem: :item_type,
+      unidadMedida: :measure_unit,
+      minimo: :minimum_stock,
+      disponibilidad: :availability
+    }.freeze
+    PROTECTED_DATA_KEYS = [:id, :company_id, :name, :code].freeze
+    DATA_KEYS_SETTERS = (ATTRIBUTES_MAPPER.values - PROTECTED_DATA_KEYS).freeze
 
     class << self
       def all(client, company)
@@ -48,14 +68,36 @@ module Colppy
     def initialize(client: nil, company: nil, **params)
       @client = client if client && client.is_a?(Colppy::Client)
       @company = company if company && company.is_a?(Colppy::Company)
-      @id = params.delete(:idItem)
-      @name = params.delete(:descripcion)
-      @sku = params.delete(:codigo)
-      @data = params
+
+      @id = params.delete(:idItem) || params.delete(:id)
+      @name = params.delete(:descripcion) || params.delete(:name)
+      @code = params.delete(:codigo) || params.delete(:code)
+
+      super(params)
+    end
+    DATA_KEYS_SETTERS.each do |data_key|
+      define_method("#{data_key}") do
+        @data[data_key.to_sym]
+      end
+      define_method("#{data_key}=") do |value|
+        @data[data_key.to_sym] = value
+      end
     end
 
     def new?
-      id.nil? || id.empty?
+      @id.nil? || @id.empty?
+    end
+
+    def exist?
+      !new?
+    end
+
+    def name=(value)
+      @name = value
+    end
+
+    def code=(value)
+      @code = value
     end
 
     def save
@@ -78,45 +120,14 @@ module Colppy
       end
     end
 
-    def name=(new_name)
-      @name = new_name
-    end
-
-    def sku=(new_sku)
-      @sku = new_sku
-    end
-
-    def []=(key, value)
-      key_sym = key.to_sym
-      if protected_data_keys.include?(key_sym)
-        raise ResourceError.new("You cannot change any of this values: #{protected_data_keys.join(", ")} manually")
-      end
-      @data[key_sym] = value
-    end
-
-    def params_for_invoice
-      {
-        idItem: id || "",
-        minimo: @data[:minimo] || "0",
-        codigo: sku || "",
-        tipoItem: @data[:tipoItem] || "P",
-        unidadMedida: @data[:unidadMedida] || "u",
-        Descripcion: name || "",
-        ImporteUnitario: @data[:precioVenta],
-        IVA: @data[:iva] || "21",
-        Comentario: @data[:detalle] || "",
-        idPlanCuenta: @data[:ctaIngresoVentas]
-      }
+    def sales_account
+      check_mandatory_account!(:sales_account)
     end
 
     private
 
     def attr_inspect
-      [:id, :sku, :name]
-    end
-
-    def protected_data_keys
-      [:idItem, :idEmpresa]
+      [:id, :code, :name]
     end
 
     def operation
@@ -132,21 +143,34 @@ module Colppy
 
     def params
       {
-        idItem: id || "",
+        idItem: @id || "",
         idEmpresa: @company.id,
-        codigo: sku || "",
-        descripcion: name || "",
-        detalle: @data[:detalle] || "",
-        precioVenta: @data[:precioVenta] || "0",
-        ultimoPrecioCompra: @data[:minimo] || "0",
-        ctaInventario: @data[:ctaInventario] || "",
-        ctaCostoVentas: @data[:ctaCostoVentas] || "",
-        ctaIngresoVentas: @data[:ctaIngresoVentas] || "",
-        iva: @data[:iva] || "21",
-        tipoItem: @data[:tipoItem] || "P",
-        unidadMedida: @data[:unidadMedida] || "u",
-        minimo: @data[:minimo] || "0"
+        codigo: @code || "",
+        descripcion: @name || "",
+        detalle: @data[:detail] || "",
+        precioVenta: @data[:sell_price] || "0",
+        ultimoPrecioCompra: @data[:last_purchase_price] || "",
+        ctaInventario: check_mandatory_account!(:inventory_account),
+        ctaCostoVentas: check_mandatory_account!(:sales_costs_account),
+        ctaIngresoVentas: check_mandatory_account!(:sales_account),
+        iva: @data[:tax] || "21",
+        tipoItem: @data[:item_type] || "P",
+        unidadMedida: @data[:measure_unit] || "u",
+        minimo: @data[:minimum_stock] || "0"
       }
     end
+
+    def check_mandatory_account!(account)
+      if account_name_or_id = @data[account]
+        real_account_name = @company.account_name(account_name_or_id)
+        if real_account_name
+          real_account_name
+        else
+          account_name_or_id
+        end
+      else
+        raise DataError.new("The :#{account} is required for the product. You should specify one via product.#{account} = '', or product[:#{account}] = '', or when you initialize it. You should check the available and valid accounts in Colppy")
+      end
+    end
   end
 end

data/lib/colppy/resources/sell_invoice.rb

@@ -1,9 +1,41 @@
 module Colppy
-  class SellInvoice < Resource
-    attr_reader :id, :number, :cae, :items, :data, :url
-    attr_accessor :payments
+  class SellInvoice < Invoice
+    attr_reader :id, :number, :cae, :url, :items
 
     VALID_RECEIPT_TYPES = %w(4 6 8 NCV)
+    ATTRIBUTES_MAPPER = {
+      descripcion: :description,
+      fechaFactura: :invoice_date,
+      idCondicionPago: :payment_condition_id, # validate
+      fechaPago: :payment_date,
+      idEmpresa: :company_id,
+      idCliente: :customer_id,
+      idEstadoAnterior: :previous_status_id, # validate
+      idEstadoFactura: :status_id, # validate
+      idMoneda: :currency_id,
+      idTipoComprobante: :receipt_type_id, # validate
+      idTipoFactura: :invoice_type_id, # validate
+      idUsuario: :user_id,
+      labelfe: :electronic_bill,
+      netoGravado: :total_taxed,
+      netoNoGravado: :total_nontaxed,
+      nroFactura1: :invoice_number1,
+      nroFactura2: :invoice_number2,
+      percepcionIIBB: :iibb_perception,
+      percepcionIVA: :tax_perception,
+      tipoFactura: :invoice_type, # validate
+      totalFactura: :total,
+      totalIVA: :total_taxes,
+      totalpagadofactura: :total_payed,
+      valorCambio: :exchange_rate,
+      nroRepeticion: :repetition_number,
+      periodoRep: :repetition_period,
+      nroVencimiento: :expiration_number,
+      tipoVencimiento: :expiration_type,
+      fechaFin: :end_date
+    }.freeze
+    PROTECTED_DATA_KEYS = [:id, :company_id, :customer_id, :number, :cae].freeze
+    DATA_KEYS_SETTERS = (ATTRIBUTES_MAPPER.values - PROTECTED_DATA_KEYS).freeze
 
     class << self
       def all(client, company)
@@ -61,13 +93,12 @@ module Colppy
 
       def extended_response(response, client, company)
         [ response[:infofactura],
-          items: response[:itemsFactura],
+          itemsFactura: response[:itemsFactura],
           url: response[:UrlFacturaPdf],
           client: client,
           company: company
         ].inject(&:merge)
       end
-
     end
 
     def initialize(client: nil, company: nil, customer: nil, **params)
@@ -75,15 +106,20 @@ module Colppy
       @company = company if company && company.is_a?(Colppy::Company)
       @customer = customer if customer && customer.is_a?(Colppy::Customer)
 
-      @id = params.delete(:idFactura)
-      @number = params.delete(:nroFactura)
+      @id = params.delete(:idFactura) || params.delete(:id)
+      @number = params.delete(:nroFactura) || params.delete(:number)
       @cae = params.delete(:cae)
 
-      @items = parse_items(params.delete(:items))
-      @payments = params.delete(:ItemsCobro) || []
+      @items = parse_items(params.delete(:itemsFactura))
+      @payments = parse_payments(params.delete(:ItemsCobro))
+      @taxes_totals = parse_taxes_totals(params.delete(:totalesiva))
 
-      @data = params
-      @url = build_pdf_url
+      super(params)
+    end
+    DATA_KEYS_SETTERS.each do |data_key|
+      define_method("#{data_key}=") do |value|
+        @data[data_key.to_sym] = value
+      end
     end
 
     def new?
@@ -94,250 +130,199 @@ module Colppy
       cae.nil? || cae.empty?
     end
 
+    def url
+      return if @data[:url].nil? || @data[:url].empty?
+
+      "#{@data[:url]}?usuario=#{@client.username}&claveSesion=#{@client.session_key}&idEmpresa=#{company_id}&idFactura=#{id}&idCliente=#{customer_id}"
+    end
+
+    def total_charged
+      @items.map(&:total_charged).inject(0,:+)
+    end
+
+    def []=(key, value)
+      ensure_editability!
+
+      super
+    end
+
+    def customer=(new_customer)
+      @customer = new_customer if new_customer.is_a?(Colppy::Customer)
+    end
+
     def save
-      ensure_editability! && ensure_client_valid! && ensure_company_valid! && ensure_customer_valid!
+      ensure_editability!
+      ensure_client_valid!
+      ensure_payment_setup!
 
       response = @client.call(
         :sell_invoice,
         :create,
         save_parameters
       )
-      binding.pry
       if response[:success]
-        @id = response[:data][:idFactura]
+        @cae = response[:cae]
+        @id = response[:idfactura]
+        @number = response[:nroFactura]
+        @data[:invoice_date] = response[:fechaFactura]
+        @data[:url] = response[:UrlFacturaPdf]
         self
       else
         false
       end
     end
 
-    def []=(key, value)
-      ensure_editability!
-
-      key_sym = key.to_sym
-      if protected_data_keys.include?(key_sym)
-        raise ResourceError.new("You cannot change any of this values: #{protected_data_keys.join(", ")} manually")
-      end
-      @data[key_sym] = value
-    end
-
-    def items=(new_items)
-      @charged_details = nil
-      @items = parse_items(new_items)
-    end
-
     private
 
     def attr_inspect
       [:id, :number, :cae]
     end
 
-    def protected_data_keys
-      [:idFactura, :idEmpresa, :nroFactura]
-    end
+    def customer_id
+      return @customer.id if @customer
 
-    def parse_items(new_items)
-      return [] if new_items.nil? || new_items.empty?
+      @data[:customer_id] || ""
+    end
+    def company_id
+      return @company.id if @company
 
-      new_items.map do |item|
-        item.tap do |hash|
-          if item[:idItem] && (item[:product].nil? || item[:product].empty?)
-            item[:product] = @company.product(item[:idItem])
-          end
-        end
+      @data[:company_id] || ""
+    end
+    def payment_condition_id
+      validate_type!(:payment_condition_id, VALID_PAYMENT_CONDITIONS)
+    end
+    def previous_status_id
+      if status = @data[:previous_status_id]
+        validate_type!(status, VALID_STATUS_ID)
+      else
+        ""
       end
     end
-
-    def build_pdf_url
-      return if data[:url].nil? || data[:url].empty?
-
-      data[:url] = "#{data[:url]}?usuario=#{@client.username}&claveSesion=#{@client.session_key}&idEmpresa=#{@company.id}&idFactura=#{id}&idCliente=#{data[:idCliente]}"
+    def status_id
+      validate_type!(:status_id, VALID_STATUS_ID)
+    end
+    def receipt_type_id
+      validate_type!(:receipt_type_id, VALID_RECEIPT_TYPES)
+    end
+    def invoice_type_id
+      validate_type!(:invoice_type_id, VALID_INVOICE_TYPES)
+    end
+    def invoice_type
+      if receipt_type_id == "8"
+        "Contado"
+      end
+    end
+    def validate_type!(data_key, valid_types)
+      type = @data[data_key]
+      if type && valid_types.include?(type)
+        type
+      else
+        raise DataError.new("The #{data_key} is invalid. The value should be any of this ones: #{valid_types.join(", ")}")
+        ""
+      end
     end
 
     def save_parameters
+      charged_amounts = calculate_charged_amounts
       [
         @client.session_params,
-        general_params,
-        invoice_payments_params,
-        itemsFactura: invoice_items_params,
-        totalesiva: total_taxes_params
+        general_params(charged_amounts),
+        itemsFactura: @items.map(&:save_parameters),
+        ItemsCobro: @payments.map(&:save_parameters),
+        totalesiva: @taxes_totals.map(&:save_parameters)
       ].inject(&:merge)
     end
 
-    def general_params
+    def general_params(charged_amounts)
       {
-        idCliente: @customer.id || @data[:idCliente] || "",
-        idEmpresa: @company.id,
+        idCliente: customer_id,
+        idEmpresa: company_id,
+        idUsuario: @client.username,
         descripcion: @data[:descripcion] || "",
-        fechaFactura: valid_date(@data[:fechaFactura]),
-        idCondicionPago: @data[:idCondicionPago] || "Contado",
-        fechaPago: valid_date(@data[:fechaPago]),
-        idEstadoAnterior: @data[:idEstadoAnterior] || "",
-        idEstadoFactura: @data[:idEstadoFactura] || "Cobrada",
-        idFactura: id || "",
-        idMedioCobro: @data[:idMedioCobro] || "Efectivo",
-        idMoneda: @data[:idMoneda] || "1",
-        idTipoComprobante: receipt_type,
-        idTipoFactura: invoice_type,
-        netoGravado: (charged_details[:total_taxed] || 0.00).to_s,
-        netoNoGravado: (charged_details[:total_non_taxed] || 0.00).to_s,
-        nroFactura1: @data[:nroFactura1] || "0001",
-        nroFactura2: @data[:nroFactura2] || "",
-        percepcionIVA: (@data[:percepcionIVA] || 0.00).to_s,
-        percepcionIIBB: (@data[:percepcionIIBB] || 0.00).to_s,
-        totalFactura: (charged_details[:total] || 0.00).to_s,
-        totalIVA: (charged_details[:tax_total] || 0.00).to_s,
-        valorCambio: @data[:valorCambio] || "1",
+        fechaFactura: valid_date(@data[:invoice_date]),
+        idCondicionPago: payment_condition_id,
+        fechaPago: valid_date(@data[:payment_date]),
+        idEstadoAnterior: previous_status_id,
+        idEstadoFactura: status_id,
+        idFactura: @id || "",
+        idMoneda: @data[:currency_id] || "1",
+        idTipoComprobante: receipt_type_id,
+        idTipoFactura: invoice_type_id,
+        netoGravado: charged_amounts[:total_taxed] || 0.00,
+        netoNoGravado: charged_amounts[:total_non_taxed] || 0.00,
+        nroFactura1: @data[:invoice_number1] || "0001",
+        nroFactura2: @data[:invoice_number2] || "00000000",
+        percepcionIVA: @data[:tax_perception] || 0.00,
+        percepcionIIBB: @data[:iibb_perception] || 0.00,
+        totalFactura: charged_amounts[:total] || 0.00,
+        totalIVA: charged_amounts[:tax_total] || 0.00,
+        valorCambio: @data[:exchange_rate] || "1",
+        nroRepeticion: @data[:repetition_number] || "1",
+        periodoRep: @data[:repetition_period] || "1",
+        nroVencimiento: @data[:expiration_number] || "0",
+        tipoVencimiento: @data[:expiration_type] || "1",
+        fechaFin: @data[:end_date] || ""
       }.tap do |params|
-        params[:labelfe] = "Factura Electrónica" if @data[:labelfe]
-      end
-    end
-
-    def invoice_items_params
-      items.map do |item|
-        if item[:product] && item[:product].is_a?(Colppy::Product)
-          product = item[:product]
-          [
-            product.params_for_invoice,
-            item_params(item, false)
-          ].inject(&:merge)
-        elsif item.is_a?(Hash)
-          item_params(item)
-        end
-      end
-    end
-
-    def item_params(item, fill_empty = true)
-      {
-        Cantidad: item[:Cantidad],
-        porcDesc: item[:porcDesc] || "0.00"
-      }.tap do |params|
-        if value = item[:ImporteUnitario] || fill_empty
-          params[:ImporteUnitario] = value || ""
-        end
-        if value = item[:idPlanCuenta] || fill_empty
-          params[:idPlanCuenta] = value || ""
-        end
-        if value = item[:IVA] || fill_empty
-          params[:IVA] = value || "21"
-        end
-        if value = item[:Comentario] || fill_empty
-          params[:Comentario] = value || ""
+        params[:tipoFactura] = invoice_type if invoice_type
+        if status_id == "Cobrada"
+          params[:totalpagadofactura] = @payments.map(&:amount).inject(0,:+)
         end
+        params[:labelfe] = "Factura Electrónica" if @data[:electronic_bill]
       end
     end
 
-    def invoice_payments_params
-      return {} unless payments
-      payment_items = payments.map do |payment|
-        {
-          idMedioCobro: payment[:idMedioCobro] || "Efectivo",
-          idPlanCuenta: payment[:idPlanCuenta] || "Caja en pesos",
-          Banco: payment[:Banco] || "",
-          nroCheque: payment[:nroCheque] || "",
-          fechaValidez: payment[:fechaValidez] || "",
-          importe: payment[:importe] || "0",
-          VAD: payment[:VAD] || "S"
-        }
-      end
-      { ItemsCobro: payment_items }
-    end
-
-    def total_taxes_params
-      charged_details[:tax_details].map do |tax, values|
-        {
-          alicuotaIva: tax.to_s,
-          baseImpIva: values[:total_taxed].to_s,
-          importeIva: values[:tax_total].to_s
-        }
-      end
-    end
-
-    def charged_details
-      return @charged_details unless @charged_details.nil? || @charged_details.empty?
-
-      if items.nil? || items.empty?
-        raise DataError.new("In order to save an SellInvoice you should at least have one item in it")
+    def calculate_charged_amounts
+      if @items.nil? || @items.empty?
+        raise DataError.new("In order to save an SellInvoice you should at least have one item in it. Add one with .add_item()")
       else
-        default_object = {
-          total_taxed: 0.00,
-          total_nontaxed: 0.00,
-          total: 0.00,
-          tax_total: 0.00,
-          tax_details:{}
-        }
-        @charged_details = items.each_with_object(default_object) do |item, result|
-          product_data = (item[:product] && item[:product].data) || {}
-          iva = (item[:IVA] || product_data[:iva] || 0).to_f
-          charged = (item[:ImporteUnitario] || product_data[:precioVenta] || 0).to_f
-          quantity = (item[:Cantidad] || 0).to_i
-          total = ( charged * quantity ).round(2)
-          if iva > 0
-            tax = (( total * iva ) / 100).round(2)
-            result[:tax_total] += tax
-            result[:total_taxed] += total - tax
-            result[:tax_details][iva] = {
-              tax_total: result[:tax_total],
-              total_taxed: result[:total_taxed]
-            }
+        charged_details = @items.each_with_object(base_charged_amounts) do |item, result|
+          tax = item.tax
+          total = item.total_charged
+          if tax > 0
+            dividend = tax.to_f
+            divisor = (100.0 + dividend).to_f
+
+            item_tax_amount = (( total * dividend ) / divisor).round(2)
+            item_taxed_amount = (total - item_tax_amount).round(2)
+            result[:tax_total] += item_tax_amount
+            result[:total_taxed] += item_taxed_amount
+            tax_breakdown_data = TaxTotal.add_to_tax_breakdown(
+              tax,
+              item_tax_amount,
+              item_taxed_amount,
+              result[:tax_breakdown][tax]
+            )
+            result[:tax_breakdown][tax] = tax_breakdown_data
           else
             result[:total_nontaxed] += total
           end
           result[:total] += total
         end
+        @taxes_totals = parse_taxes_totals(charged_details[:tax_breakdown].values)
+        charged_details
       end
     end
 
+    def base_charged_amounts
+      {
+        total_taxed: 0.00,
+        total_nontaxed: 0.00,
+        total: 0.00,
+        tax_total: 0.00,
+        tax_breakdown: {}
+      }
+    end
+
     def ensure_editability!
       unless editable?
         raise ResourceError.new("You cannot change any value of this invoice, because it's already processed by AFIP. You should create a new one instead")
       end
     end
 
-    def invoice_status
-      type = @data[:idEstadoFactura]
-      if type && VALID_INVOICE_STATUS.include?(type)
-        type
-      else
-        raise DataError.new("The value of idEstadoFactura:#{type} is invalid. The value should be any of this ones: #{VALID_INVOICE_STATUS.join(", ")}")
-      end
-    end
-
-    def invoice_type
-      type = @data[:idTipoFactura]
-      if type && VALID_INVOICE_TYPES.include?(type)
-        type
-      else
-        raise DataError.new("The idTipoFactura:#{type} is invalid. The value should be any of this ones: #{VALID_INVOICE_TYPES.join(", ")}")
-      end
-    end
-
-    def receipt_type
-      type = @data[:idTipoComprobante]
-      if type && VALID_RECEIPT_TYPES.include?(type)
-        type
-      else
-        raise DataError.new("The idTipoComprobante:#{type} is invalid. The value should be any of this ones: #{VALID_RECEIPT_TYPES.join(", ")}")
-        ""
+    def ensure_payment_setup!
+      if status_id == "Cobrada" && (@payments.nil? || @payments.empty?)
+        raise ResourceError.new("You cannot save this invoice, because it's doesn't have any payment associated to it and the status is #{@data[:status_id]}. Add one calling .add_payment({})")
       end
     end
   end
 end
-
-# "totalesiva":[
-#   {
-#     alicuotaIva: "0",
-#     baseImpIva: "0.00",
-#     importeIva: "0.00"
-#   },
-  # {
-  #   alicuotaIva: "21",
-  #   baseImpIva: "101.65",
-  #   importeIva: "21.35"
-  # },
-#   {
-#     alicuotaIva: "27",
-#     baseImpIva: "0.00",
-#     importeIva: "0.00"
-#   }
-# ]

data/lib/colppy/utils.rb

@@ -0,0 +1,21 @@
+module Colppy
+  module Utils
+    module_function
+
+    ATTRIBUTES_MAPPER = {}
+    DATA_KEYS_SETTERS = []
+
+    def rename_params_hash(params, mapper, setter)
+      params.each_with_object({}) do |(key, value), hash|
+        if new_key = mapper[key]
+          hash[new_key] = value
+        elsif setter.include?(key)
+          hash[key] = value
+        else
+          hash[:unhandle] ||= {}
+          hash[:unhandle][key] = value
+        end
+      end
+    end
+  end
+end

data/lib/colppy/version.rb

@@ -1,3 +1,3 @@
 module Colppy
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: colppy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Agustin Cavilliotti
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-01 00:00:00.000000000 Z
+date: 2016-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -143,9 +143,11 @@ files:
 - lib/colppy/resource.rb
 - lib/colppy/resources/company.rb
 - lib/colppy/resources/customer.rb
+- lib/colppy/resources/invoice.rb
 - lib/colppy/resources/product.rb
 - lib/colppy/resources/sell_invoice.rb
 - lib/colppy/resources/user.rb
+- lib/colppy/utils.rb
 - lib/colppy/version.rb
 homepage: https://github.com/goodpeople/colppy
 licenses: