Modificaciones y correcciones varias

Gemfile

@@ -3,7 +3,7 @@ source "http://rubygems.org"
 platforms :ruby_19 do
   gem "httpi", "0.7.9"
 end
-gem "savon"
+gem "savon", "1.2.0"
 
 group :development do
   platforms :ruby_18 do

README.textile

@@ -16,11 +16,28 @@ o
 
 en tu @Gemfile@
 
+Nota: Para que funcione el proceso de autenticación WSAA, chequear si el openssl instalado tiene compilado el módulo "cms" :
+<pre>openssl cms</pre>
+
+Si no dice "Invalid command", estamos bien. Caso contrario, descargar openssl y compilarlo con:
+<pre>./configure enable-cms
+make
+make install
+</pre>
+
+Nota 2: Ojo! Probablemente el openssl instalado originalmente sea el que se acceda por el path. Normalmente esto lo soluciona:
+
+<pre>whereis openssl
+mv SALIDA_DEL_WHEREIS SALIDA_DEL_WHEREIS_old
+ln -s /usr/local/ssl/bin/openssl SALIDA_DEL_WHEREIS
+</pre>
 
 h2. Configuraci&oacute;n
 
 Los servicios de AFIP requieren la utilizaci&oacute;n del Web Service de Autorizaci&oacute;n y Autenticaci&oacute;n ("wsaa readme":http://www.afip.gov.ar/ws/WSAA/README.txt)
 
+Nota: El proceso de WSAA en Bravo está implementado con un script Bash. Esto es incompatible con un servidor Windows.
+
 Luego de cumplidos los pasos indicados en el readme, basta con configurar Bravo con la ruta a los archivos:
 
 <pre>

bravo.gemspec

@@ -58,7 +58,7 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<savon>, [">= 0"])
+      s.add_runtime_dependency(%q<savon>, ["= 1.2.0"])
       s.add_development_dependency(%q<ruby-debug>, [">= 0"])
       s.add_development_dependency(%q<ruby-debug-base19>, ["= 0.11.24"])
       s.add_development_dependency(%q<ruby-debug19>, ["= 0.11.6"])
@@ -67,7 +67,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<jeweler>, ["~> 1.5.1"])
       s.add_development_dependency(%q<rcov>, [">= 0"])
     else
-      s.add_dependency(%q<savon>, [">= 0"])
+      s.add_dependency(%q<savon>, ["= 1.2.0"])
       s.add_dependency(%q<ruby-debug>, [">= 0"])
       s.add_dependency(%q<ruby-debug-base19>, ["= 0.11.24"])
       s.add_dependency(%q<ruby-debug19>, ["= 0.11.6"])
@@ -77,7 +77,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<rcov>, [">= 0"])
     end
   else
-    s.add_dependency(%q<savon>, [">= 0"])
+    s.add_dependency(%q<savon>, ["= 1.2.0"])
     s.add_dependency(%q<ruby-debug>, [">= 0"])
     s.add_dependency(%q<ruby-debug-base19>, ["= 0.11.24"])
     s.add_dependency(%q<ruby-debug19>, ["= 0.11.6"])

lib/bravo.rb

@@ -5,6 +5,10 @@
 require "bravo/core_ext/float"
 require "bravo/core_ext/hash"
 require "bravo/core_ext/string"
+
+require 'net/http'
+require 'net/https'
+
 module Bravo
 
   class NullOrInvalidAttribute < StandardError; end
@@ -26,10 +30,20 @@ def auth_hash
   def log?
     Bravo.verbose || ENV["VERBOSE"]
   end
+
+  def deleteToken
+      AuthData.deleteToken
+  end
+
+  def token_modified_at
+      AuthData.token_modified_at
+  end
+
 
 end
 
 Savon.configure do |config|
-  config.log = Bravo.log?
+  config.logger = Rails.logger
+  config.log = true # Bravo.log?
   config.log_level = :debug
 end

lib/bravo/auth_data.rb

@@ -11,19 +11,49 @@ def fetch
           raise "Archivo certificado no encontrado en #{Bravo.cert}"
         end
 
-        todays_datafile = "/tmp/bravo_#{Time.new.strftime('%d_%m_%Y')}.yml"
         opts = "-u #{Bravo.auth_url}"
         opts += " -k #{Bravo.pkey}"
-        opts += " -c #{Bravo.cert}"
+        opts += " -c #{Bravo.cert}" 
+        opts += " -a #{todays_datafile}"
 
-        unless File.exists?(todays_datafile)
-          %x(#{File.dirname(__FILE__)}/../../wsaa-client.sh #{opts})
+        unless File.exists?(todays_datafile) and File.size(todays_datafile) > 29 # Avoid empty tokens
+          File.delete(todays_datafile) if File.exists?(todays_datafile)
+          command = "#{File.dirname(__FILE__)}/../../wsaa-client.sh #{opts}"
+          Rails.logger.warn "Haciendo request a WSAA: " + command
+          rsp = %x(bash #{command} )
         end
 
         @data = YAML.load_file(todays_datafile).each do |k, v|
-          Bravo.const_set(k.to_s.upcase, v) unless Bravo.const_defined?(k.to_s.upcase)
+          Bravo.const_set(k.to_s.upcase, v) #unless Bravo.const_defined?(k.to_s.upcase)
         end
+
+        error_msg = nil
+        if @data["error"].present?
+          File.delete(todays_datafile) if File.exist?(todays_datafile)
+          error_msg = "Error autentificando con AFIP: #{@data["error"]}"
+        elsif not File.exists?(todays_datafile)
+          error_msg = "Error autentificando con AFIP, vuelva a intentar."
+        end
+
+        if error_msg
+          Rails.logger.warn error_msg
+          raise error_msg
+        end
+
       end
+
+      def deleteToken
+        %x(rm #{todays_datafile})
+      end
+
+      def token_modified_at
+        File.exist?(todays_datafile) ? File.mtime(todays_datafile) : nil
+      end
+
+      def todays_datafile
+        Dir.pwd + "/tmp/bravo_#{Bravo.cuit}_#{Time.new.strftime('%d_%m_%Y')}.yml"
+      end
+
     end
   end
 end

lib/bravo/bill.rb

@@ -1,9 +1,10 @@
 module Bravo
   class Bill
     attr_reader :client, :base_imp, :total
-    attr_accessor :net, :doc_num, :iva_cond, :documento, :concepto, :moneda,
-                  :due_date, :aliciva_id, :fch_serv_desde, :fch_serv_hasta,
-                  :body, :response
+    attr_accessor :net, :doc_num, :iva_cond, :recipient_iva_cond,
+                  :documento, :concepto, :moneda,
+                  :due_date, :fch_serv_desde, :fch_serv_hasta, :fch_emision,
+                  :body, :response, :ivas, :related_invoice_data
 
     def initialize(attrs = {})
       Bravo::AuthData.fetch
@@ -15,6 +16,11 @@ def initialize(attrs = {})
         http.read_timeout = 90
         http.open_timeout = 90
         http.headers = { "Accept-Encoding" => "gzip, deflate", "Connection" => "Keep-Alive" }
+
+        # Insist because this config doesn't stick from bravo.rb for some reason
+        config.logger = Rails.logger
+        config.log = true
+        config.log_level = :debug
       end
 
       @body           = {"Auth" => Bravo.auth_hash}
@@ -23,6 +29,7 @@ def initialize(attrs = {})
       self.moneda     = attrs[:moneda]    || Bravo.default_moneda
       self.iva_cond   = attrs[:iva_cond]
       self.concepto   = attrs[:concepto]  || Bravo.default_concepto
+      self.ivas = attrs[:ivas] || Array.new # [ 1, 100.00, 10.50 ], [ 2, 100.00, 21.00 ] 
     end
 
     def cbte_type
@@ -44,8 +51,14 @@ def total
     end
 
     def iva_sum
-      @iva_sum = net * Bravo::ALIC_IVA[aliciva_id][1]
-      @iva_sum.round_up_with_precision(2)
+      @iva_sum = 0.0
+      self.ivas.each{ |i|
+        @iva_sum += i[1] * Bravo::ALIC_IVA[ i[0] ][1]
+        # @iva_sum += i[2] 
+      }
+      #@iva_sum = net * Bravo::ALIC_IVA[TODO][1]
+      #@iva_sum.round_up_with_precision(2)
+      @iva_sum.round(2)
     end
 
     def authorize
@@ -60,35 +73,73 @@ def authorize
     end
 
     def setup_bill
-      today = Time.new.strftime('%Y%m%d')
+      if fch_emision then
+        fecha_emision = fch_emision.strftime('%Y%m%d')
+      else
+        fecha_emision = Time.new.strftime('%Y%m%d') #today
+      end
+
+
+      array_ivas = Array.new
+      self.ivas.each{ |i|
+          array_ivas << {
+              "Id" => Bravo::ALIC_IVA[ i[0] ][0],
+              "BaseImp" => i[1] ,
+              "Importe" => i[2] }
+      }
 
       fecaereq = {"FeCAEReq" => {
                     "FeCabReq" => Bravo::Bill.header(cbte_type),
                     "FeDetReq" => {
                       "FECAEDetRequest" => {
                         "Concepto"    => Bravo::CONCEPTOS[concepto],
                         "DocTipo"     => Bravo::DOCUMENTOS[documento],
-                        "CbteFch"     => today,
+                        "CbteFch"     => fecha_emision,
                         "ImpTotConc"  => 0.00,
                         "MonId"       => Bravo::MONEDAS[moneda][:codigo],
                         "MonCotiz"    => exchange_rate,
                         "ImpOpEx"     => 0.00,
-                        "ImpTrib"     => 0.00,
-                        "Iva"         => {
-                          "AlicIva" => {
-                            "Id" => "5",
-                            "BaseImp" => net,
-                            "Importe" => iva_sum}}}}}}
+                        "ImpTrib"     => 0.00
+                    }}}}
+
+      if Bravo.own_iva_cond == :responsable_inscripto
+        fecaereq["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"]["Iva"] = { "AlicIva" => array_ivas }
+      elsif Bravo.own_iva_cond == :responsable_monotributo and array_ivas.any?
+        raise "No incluir montos iva al facturar como Responsable Monotributo"
+      end
+
+      self.recipient_iva_cond = parse_iva_cond(self.recipient_iva_cond) if self.recipient_iva_cond.is_a?(Symbol)
+      if not self.recipient_iva_cond.is_a?(Integer)
+        raise "La condición IVA del receptor es un campo requerido desde el 1/8/2025"
+      end
 
       detail = fecaereq["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"]
 
       detail["DocNro"]    = doc_num
+      detail["CondicionIVAReceptorId"] = self.recipient_iva_cond
       detail["ImpNeto"]   = net.to_f
       detail["ImpIVA"]    = iva_sum
-      detail["ImpTotal"]  = total
+      detail["ImpTotal"]  = total.round(2)
       detail["CbteDesde"] = detail["CbteHasta"] = next_bill_number
 
-      unless concepto == 0
+      if related_invoice_data
+        detail["CbtesAsoc"] = {
+          "CbteAsoc" => [{
+            "Tipo" => related_invoice_data[:type],
+            "PtoVta" => related_invoice_data[:sale_point],
+            "Nro" => related_invoice_data[:number],
+            "Cuit" => related_invoice_data[:cuit],
+            "CbteFch" => related_invoice_data[:date]
+          }]
+        }
+      elsif ["02", "03", "07", "08"].include?(cbte_type) # NC/ND only
+        detail["PeriodoAsoc"] = {
+          "FchDesde" => fch_emision.beginning_of_month.strftime('%Y%m%d'),
+          "FchHasta" => fch_emision.strftime('%Y%m%d')
+        }
+      end
+
+      unless concepto == "Productos" # En "Productos" ("01"), si se mandan estos parámetros la afip rechaza.
         detail.merge!({"FchServDesde" => fch_serv_desde || today,
                       "FchServHasta"  => fch_serv_hasta || today,
                       "FchVtoPago"    => due_date       || today})
@@ -106,8 +157,27 @@ def next_bill_number
       resp.to_hash[:fe_comp_ultimo_autorizado_response][:fe_comp_ultimo_autorizado_result][:cbte_nro].to_i + 1
     end
 
-    def authorized?
-      !response.nil? && response.header_result == "A" && response.detail_result == "A"
+    def authorized?       
+        !response.nil? && response.header_result == "A" && response.detail_result == "A"
+    end
+
+    def search(cbte_type, cbte_nro, pto_vta)
+      fecompconsultarreq = {
+        "FeCompConsReq" => {
+          "CbteTipo" => cbte_type,
+          "CbteNro" => cbte_nro,
+          "PtoVta" => pto_vta
+        }
+      }
+      body.merge!(fecompconsultarreq)
+
+      response = client.request("FECompConsultar", soap_action: "http://ar.gov.afip.dif.FEV1/FECompConsultar") do |soap|
+        soap.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
+        soap.body = body
+      end
+      puts "FECompConsultar --> "
+      puts body
+      return response.to_json
     end
 
     private
@@ -122,16 +192,34 @@ def setup_response(response)
       # TODO: turn this into an all-purpose Response class
 
       result          = response[:fecae_solicitar_response][:fecae_solicitar_result]
-
+
+      if not result[:fe_det_resp] or not result[:fe_cab_resp] then 
+      # Si no obtuvo respuesta ni cabecera ni detalle, evito hacer '[]' sobre algo indefinido.                        
+      # Ejemplo: Error con el token-sign de WSAA
+          keys, values = {
+                :errores => result[:errors],
+                :header_result => {:resultado => "X" },
+                :observaciones => nil
+          }.to_a.transpose
+          self.response = (defined?(Struct::ResponseMal) ? Struct::ResponseMal : Struct.new("ResponseMal", *keys)).new(*values)         
+          return
+      end       
+
       response_header = result[:fe_cab_resp]
       response_detail = result[:fe_det_resp][:fecae_det_response]
 
       request_header  = body["FeCAEReq"]["FeCabReq"].underscore_keys.symbolize_keys
       request_detail  = body["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"].underscore_keys.symbolize_keys
-
-      iva             = request_detail.delete(:iva)["AlicIva"].underscore_keys.symbolize_keys
-
-      request_detail.merge!(iva)
+
+      # Esto no funciona desde que se soportan múltiples alícuotas de iva simultáneas
+      # FIX ? TO-DO
+      # iva             = request_detail.delete(:iva)["AlicIva"].underscore_keys.symbolize_keys
+      # request_detail.merge!(iva) 
+
+      if result[:errors] then
+          response_detail.merge!( result[:errors] )     
+      end
+
 
       response_hash = {:header_result => response_header.delete(:resultado),
                        :authorized_on => response_header.delete(:fch_proceso),
@@ -143,11 +231,23 @@ def setup_response(response)
                        :moneda        => request_detail.delete(:mon_id),
                        :cotizacion    => request_detail.delete(:mon_cotiz),
                        :iva_base_imp  => request_detail.delete(:base_imp),
-                       :doc_num       => request_detail.delete(:doc_nro)
+                       :doc_num       => request_detail.delete(:doc_nro), 
+                       :observaciones => response_detail.delete(:observaciones),
+                       :errores       => response_detail.delete(:err) 
                        }.merge!(request_header).merge!(request_detail)
 
       keys, values  = response_hash.to_a.transpose
-      self.response = (defined?(Struct::Response) ? Struct::Response : Struct.new("Response", *keys)).new(*values)
+
+      #self.response = (defined?(Struct::Response) ? Struct::Response : Struct.new("Response", *keys)).new(*values)
+      # Even if it throws a warning, it avoids some parsing errors.
+      self.response = Struct.new("Response", *keys).new(*values)
+    end
+
+    def parse_iva_cond(sym)
+      return 1 if sym == :responsable_inscripto
+      return 6 if sym == :monotributo
+      return 5 if sym == :consumidor_final
+      return 4 if sym == :exento
     end
   end
 end