snoopy_afip 2.1.1 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
----
-SHA1:
-  metadata.gz: e1b6ea5c224ff75e7dc085b10b57acc2a93125b7
-  data.tar.gz: 6c488db06f8c01ee165fa1c3ea45846b862148db
-SHA512:
-  metadata.gz: 964dd0b5447d8bcd6a9d6ec5b290636002460b6069061a9527d8aefb2158c643d0fc31b54365ee2415750caf339680152850ba313d8e30579f64b66f6736566a
-  data.tar.gz: b659f8fae3b64992d40cd607e3cff4b663eedbe95a43823fa61eeaa09551886df9fa30c8ed8084dcf04a44b49cb262db6bb83f258432015eb1e3eac8b1a05a20
+--- 
+SHA512: 
+  data.tar.gz: cc38b0368056ee06c4dc5356d4d28266f85b398dd213255594ca2a1abbf18bab472707a1e530823c5d609d2243d4c89de375584719bbc209ee68972309eea1e9
+  metadata.gz: 8ebd13756ee6fc97af51cc5bcea676c059e117e2fa5cc1695a0438d469daa8003aa19975d778ad88a9fcea9204d57d31cb7c2d6b9471c58a588b6335c3c30650
+SHA1: 
+  data.tar.gz: 5e690eecae91ab18eae8e224f63c96ffdf883da8
+  metadata.gz: 6ba0173aef930a56479a87d58e60ac13708090c9

data/CHANGELOG

@@ -1,23 +1,23 @@
-*Bravo 0.4.0 (March 21, 2011)*
-
-* Auth service URL is now part of the config [miloops]
-
-*Bravo 0.3.6 (March 14, 2011)*
-
-* Hash extensions play nice with Rails 2.3 ruby 1.9 [miloops]
-
-*Bravo 0.3.5 (March 11, 2011)* (in version 0.3.5 this is listed as 0.4.0)
-
-* Errors will be raised if CERT or PKEY are not present [miloops]
-* Removed various hardcoded options [leanucci]
-* Added support for more iva conditions [miloops]
-* Log verbosity switch [leanucci]
-* Better spec coverage
-
-*Bravo 0.3.0 (March 07, 2011)*
-
-* Bill#response returns the full list of parameters passed and returned by FECAESolicitar [leanucci]
-
-*Bravo 0.2.0 (March 04, 2011)*
-
-* Bill#response returns a complete hash from WSFE response [leanucci]
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [3.0.0] - June 29, 2017
+### Added
+- `Authentication Class` destinada a la comunicación con el **WSAA**.
+- `Authorize Class` destinada a la comunicación con el **WSFE**.
+- `Client Class` destinada para crear el cliente de `Savon`.
+- Mejor manejo de Exceptions.
+- Validaciones en el modelo `Bill`.
+
+### Changed
+- Se pasó toda la logica de comunicación con el **WSFE** del modelo `Bill` al modelo `Authorize`.
+- No se crea mas el rchivo para la clave privada, devuelve en RAW.
+- No se crea mas un archivo para almacenar el _token_, _sign_, se devuelve en RAW.
+- Evitar raisear si se logró autorizar una factura con el **WSFE**. Manejo en el errors del `Bill` o el `Authorize`.
+
+### Removed
+- Eliminiado modulo `AuthData`.
+- Eliminado el uso de `Bash` para autenticar en el **WSAA**.

data/README.textile

@@ -0,0 +1,236 @@
+# snoopy_afip
+conexión con Web Service de Factura Electrónica de AFIP (WSFE)
+
+## Instalación
+
+Añadir esta linea en el Gemfile:
+
+```ruby
+gem 'snoopy_afip'
+```
+
+Luego ejecuta:
+
+    $ bundle
+
+O instala la gema a mano:
+
+    $ gem install snoopy_afip
+
+### Versiones
+
+- `2.1.1`. Usada en producción. (**Stable**)
+- `3.0.0`. Aun en entorono de testing. (**Beta**)
+
+## Antes que nada
+
+* Link con el manual para desarrolladores.
+
+- [Especificación Técnica WSAA]('http://www.afip.gov.ar/ws/WSAA/Especificacion_Tecnica_WSAA_1.2.0.pdf'): Especificación técnica para la comunicación con el **WSAA** (servicio de autenticación), su propósito es solicitar un _tocken_ y _sign_ para poder emitir facturas con el servicio de **WSFE** (Servicio de autorización de facturas)
+
+- [Manual desarrollador](http://www.afip.gob.ar/fe/documentos/manual_desarrollador_COMPG_v2_9.pdf): Especificación técnica para la comunicación con **WSFE** (Servicio de autorización de facturas).
+
+* Es recomendable descargar los **Wsdl** para evitar tener que pedirlo en cada request
+
+- Wsdl **WSAA** (servicio de autenticación)
+
+  - Testing:    [https://wsaahomo.afip.gov.ar/ws/services/LoginCms?wsdl]('https://wsaahomo.afip.gov.ar/ws/services/LoginCms?wsdl')
+  - Producción: [https://wsaa.afip.gov.ar/ws/services/LoginCms?wsdl]('https://wsaa.afip.gov.ar/ws/services/LoginCms?wsdl')
+
+- **WSFE** (Servicio de autorización de facturas)
+
+  - Testing:    [https://wswhomo.afip.gov.ar/wsfev1/service.asmx?wsdl]('https://wswhomo.afip.gov.ar/wsfev1/service.asmx?wsdl')
+  - Producción: [https://servicios1.afip.gov.ar/wsfev1/service.asmx?WSDL]('https://servicios1.afip.gov.ar/wsfev1/service.asmx?WSDL')
+
+* Explicación detallada de los pasos a seguir para obtener el certificado desde el sitio web AFIP para emitir facturas electrónicas.
+
+[obtención de certificado](https://www.afip.gob.ar/ws/WSAA/WSAA.ObtenerCertificado.pdf)
+
+## USO
+
+### Inicialización de parametros generales
+
+```ruby
+Snoopy.default_currency      = :peso
+Snoopy.default_concept       = 'Servicios'
+Snoopy.default_document_type = 'CUIT' || 'DNI' # O alguna key de Snoopy::DOCUMENTS
+# Para el caso de produccion
+Snoopy.auth_url    = 'https://wsaa.afip.gov.ar/ws/services/LoginCms?wsdl' || PATH_WSAA_PROP_WSDL
+Snoopy.service_url = 'https://servicios1.afip.gov.ar/wsfev1/service.asmx?WSDL' || PATH_WSFE_PROP_WSDL
+# Para el caso de desarrollo
+Snoopy.auth_url    = 'https://wsaahomo.afip.gov.ar/ws/services/LoginCms?wsdl' || PATH_WSAA_TEST_WSDL
+Snoopy.service_url = 'https://wswhomo.afip.gov.ar/wsfev1/service.asmx?wsdl' || PATH_WSFE_TEST_WSDL
+```
+
+En caso de trabajar con `Ruby on Rails`, es recomendable crear un archivo con esta conf en `config/initializers/snoopy.rb`.
+
+### Generar Clave privada
+
+```ruby
+Snoopy::AuthenticationAdapter.generate_pkey(2048) # Si no se pasa argumento se generar una de 8192
+```
+
+Este metodo retorna el `RAW` de la pkey, la cual debera guardarse en algun archivo o alguna base de datos.
+
+### Generar solicitud de pedido de certificado
+
+#### With ruby
+
+Este metodo aun no ha sido testeado, por lo que agredezco si alguien logra probarlo.
+
+```ruby
+Snoopy::AuthenticationAdapter.generate_certificate_request_with_ruby(pkey_path, subj_o, subj_cn, subj_cuit)
+```
+
+#### With bash
+
+Mantiene la generación de versiones pasadas de `Snoopy`
+
+```bash
+Snoopy::AuthenticationAdapter.generate_certificate_request_with_bash(pkey_path, subj_o, subj_cn, subj_cuit)
+```
+
+- `pkey_path`: Ruta absoluta de la llave privada.
+- `subj_o`: Nombre de la compañia.
+- `subj_cn`: Hostname del server que generará las solicitudes. En ruby se obtiene con `%x(hostname).chomp`
+- `subj_cuit`: Cuit registrado en la AFIP de la compañia que emita facturas.
+
+Una vez generado este archivo debe hacerse el tramite en el sitio web de la **AFIP** para obtener el certificado que permitirá autorizar facturas al webservice.
+
+### Solicitar autorización para la emisión de facturas
+
+Para poder emitir o autorizar facturas en el web service de la **AFIP** es necesario solicitar autorización.
+
+```ruby
+# pkey_path: Ruta absoluta de la llave privada.
+# cert_path: Ruta absoluta del cetificado obtendio del sitio oficial de la **AFIP**.
+authentication_adapter = Snoopy::AuthenticationAdapter.new(pkey_path, pkey_cert)
+authentication_adapter.authenticate!
+```
+
+`authentication_adapter.authenticate!` deberá retornar un `Hash` con las siguientes keys: `:token`, `:sign` y `:expiration_time`
+
+La key `:expiration_time` determina hasta cuando se podrá autorizar facturas, el tiempo esta prefijado por **AFIP** y es el de 24 Horas desde el momento de la solicitud del **token sign**, superado este tiempo deberá solicitarse nuevamente un **token sign**.
+
+```ruby
+# Response example
+{ token: "PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8c3NvIHZlcnNpb249IjIuMCI+CiAgICA8aWQgdW5pcXVlX2lkPSI5MDIxNDczOTEiIHNyYz0iQ049d3NhYWhvbW8sIE89QUZJUCwgQz1BUiwgU0VSSUFMTlVNQkVSPUNVSVQgMzM2OTM0NTAyMzkiIGdlbl90aW1lPSIxNDk4NDk0NDQ1IiBleHBfdGltZT0iMTQ5ODUzNzcwNSIgZHN0PSJDTj13c2ZlLCBPPUFGSVAsIEM9QVIiLz4KICAgIDxvcGVyYXRpb24gdmFsdWU9ImdyYW50ZWQiIHR5cGU9ImxvZ2luIj4KICAgICAgICA8bG9naW4gdWlkPSJDPWFyLCBPPXNlcXVyZSBzYSwgU0VSSUFMTlVNQkVSPUNVSVQgMjAyNDE2MDgxNjcsIENOPXBjIiBzZXJ2aWNlPSJ3c2ZlIiByZWdtZXRob2Q9IjIyIiBlbnRpdHk9IjMzNjkzNDUwMjM5IiBhdXRobWV0aG9kPSJjbXMiPgogICAgICAgICAgICA8cmVsYXRpb25zPgogICAgICAgICAgICAgICAgPHJlbGF0aW9uIHJlbHR5cGU9IjQiIGtleT0iMjAyNDE2MDgxNjciLz4KICAgICAgICAgICAgPC9yZWxhdGlvbnM+CiAgICAgICAgPC9sb2dpbj4KICAgIDwvb3BlcmF0aW9uPgo8L3Nzbz4KCg==",
+  sign: "iSpp/5qxQntuzOQcqs6GlShFaOKtEagLY17TFDwMTiErquT/fEw5ki9Ff4RYGndc/49UGmUTnVjUqB0mxuJk2IG4t+J4AAyVsY6+xiBGvMXAM/5sAI78NDl7ibMxAcdPi+nBIrdydp5DLy2SB4u/G46kguc6+srBp2fo20f/+wM=",
+  expiration_time: #<DateTime: 2017-06-27T01:28:25-03:00 ((2457932j,16105s,963000000n),-10800s,2299161j)>}}
+```
+
+En caso de producirse algun tipo de error este será devuelto a traves de raise exception. El error mas comun puede deberse al que certificado obtenido a treves del pedido de cetificado no sea correcto.
+
+### Autorizar factura
+
+#### Crear `Bill`
+```ruby
+Snoopy::Bill.new(attrs)
+
+```
+Donde `attrs` debe estar conformado de la siguiente manera:
+* `attrs[:cuit]`                    CUIT del emisor de la factura.
+* `attrs[:concept]`                 Concepto de la factura, por defecto `Snoopy.default_concept`.
+* `attrs[:imp_iva]`                 Monto total de impuestos.
+* `attrs[:currency]`                Tipo de moneda a utilizar, por default `Snoopy.default_currency`.
+* `attrs[:alicivas]`                Impuestos asociados a la factura.
+* `attrs[:total_net]`               Monto neto por defecto es 0.
+* `attrs[:sale_point]`              Punto de venta del emisor de la factura.
+* `attrs[:document_type]`           Tipo de documento a utilizar, por default `Snoopy.default_document`. Valores posibles `Snoopy::DOCUMENTS`
+* `attrs[:document_num]`            Numero de documento o cuit, el valor depende de `attrs[:document_type]`.
+* `attrs[:issuer_iva_cond]`         Condición de IVA del emisor de la factura. [`Snoopy::RESPONSABLE_INSCRIPTO` o `Snoopy::RESPONSABLE_MONOTRIBUTO`]
+* `attrs[:receiver_iva_cond]`       valores posibles `Snoopy::BILL_TYPE`
+* `attrs[:service_date_from]`       Inicio de vigencia de la factura.
+* `attrs[:service_date_to]`         Fin de vigencia de la factura.
+* `attrs[:cbte_asoc_num]`           Numero de la factura a la cual se quiere crear una nota de crédito (Solo pasar si se esta creando una nota de crédito).
+* `attrs[:cbte_asoc_to_sale_point]` Punto de venta de la factura a la cual se quiere crear una nota de crédito (Solo pasar si se esta creando una nota de crédito).
+
+El `attrs[:alicivas]` discrimina la información de los items. Es posible que en la factura se discriminen diferentes items con diferentes impuestos. Para ello el `attrs[:alicivas]` es un arreglo de `Hash`. Donde cada uno de ellos tiene la información sobre un determinado impuesto.
+
+```ruby
+{ id:            tax_rate.round_with_precision(2),    # Porcentaje. Ej: "0.105", "0.21", "0.27"
+  amount:        tax_amount.round_with_precision(2),  # Monto total del impuesto del item.
+  taxeable_base: net_amount.round_with_precision(2) } # Monto total del item sin considerar el impuesto.
+```
+
+Por ejemplo si se tiene 5 items, donde 3 de ellos tienen un impuesto del 10.5% y los 2 restantes del 21%. Los primeros 3 deben, se debera de crear dos hashes de la siguientes forma.
+
+```ruby
+attrs[:alicivas] = [ { id: (10.5 / 100 ).to_s 
+                       amount: X,            # De los 3 items de 10.5
+                       taxeable_base: Y },   # De los 3 items de 10.5
+                     { id: (21 / 100 ).to_s 
+                       amount: X,            # De los 2 items de 21
+                       taxeable_base: Y } ]  # De los 2 items de 21
+```
+Donde: 
+
+* `X`: Es la parte del monto que le corresponde al impuesto.
+* `Y`: Es la partes del monto sin impuesto.
+
+Los `tax_rates` soportados por AFIP son los siguientes:
+
+```ruby
+Snoopy::ALIC_IVA
+```
+
+* Tips:
+
+El `taxeable_base` se calcula de la siguiente manera:
+
+```ruby
+total_amount / (1 + tax_percentage)
+```
+  
+- Metodos de interes
+  - **valid?**            valida si la `bill` cumple lo minimo indispensable.
+  - **partial_approved?** si fue _Aprobada parcialmente_ por el webserice.
+  - **rejected?**         si fue _Rechazada_ por el webservice.
+  - **approved?**         si fue _Aprobada_ por el webservice.
+  - **errors**            errores presentados durante la validación `valid?`
+
+#### Autorizar el `Bill`
+```ruby
+authorize_adapter = Snoopy::AuthorizeAdapter.new({ bill: bill,        # Obtenido en el paso anterior
+                                                   pkey: pkey,        # PATH de la clave privada generada anteriormente.
+                                                   cert: certificate, # PATH del certificado descargado del sitio web de la AFIP.
+                                                   cuit: cuit,        # CUIT del emisor de la factura, mismo con el que se hizo el tramite.
+                                                   sign: sign,        # SIGN obtenido en la autenticación
+                                                   token: token})     # TOKEN obtenido en la autenticación
+                                                   
+authorize_adapter.authorize!
+```
+
+- Metodos de interes del `Snoopy::AuthorizeAdapter`
+
+  - **request** Información enviada al webservice de **AFIP**
+  - **response** Respuesta completa obtenida del webservice de **AFIP**
+  - **afip_errors** Errores parseados de la **response**. Pueden presentarse los motivos por los que no se autorizo la `bill`
+  - **afip_events** Eventos parseados de la **response** . Generalmente la **AFIP** los usa para informar de posibles cambios.
+  - **afip_observations** Observaciones parseados de la **response**. Pueden presentarse los motivos por los que no se autorizo la `bill`
+  - **errors** Errores presentados en el proceso de autorización. Explicado en el apartado siguiente.
+
+### Manejo de excepciones
+
+#### Explota
+
+Hay errores que producirán que `Snoopy` generé un `raise`, estos son los casos que se produzcan errores previo o durante la comunicación con la **AFIP**. En estos casos se produce un `raise` debido a que no se logro la comunicación con la **AFIP** por lo que se puede asegurar que no se autorizo la `bill`
+
+#### No Explota
+Existe otro caso que se produzca un error posterior a la comunicación con el webservice, en este caso se pudo obtener una respuesta , pero se producierón errores en el parseo de la misma (Por ejemplo **AFIP** cambia el formato de la response), para ellos se puede consultar las exceptiones generadas por los parseadores con `authorize_adapter.errors`. 
+
+Hay 4 nivel de parser:
+- **Obtención del resultado, cae, fecha de vencimiento del cae y el bill number**: Este es el nivel de parser mas **importante** dado que si este no se pudo realizar, es imposible saber que sucedio durante la autorización. Pero no preocuparse por que esta la response completa en `authorize_adapter.response`
+- **Parseo de errores**: Parsea los errores retornados por la **AFIP**.
+- **Parseo de eventos**: Parsea los eventos retornados por la **AFIP**.
+- **Parseo de observaciones**: Parsea las observaciones retornados por la **AFIP**.
+
+Implemente esto de esta manera debido a que sucedio que **AFIP** cambio algo en la estructura de los eventos, y al tener todo en un solo parser explotaba todo y no sabia que habia sucedido con la autorización de la factura.
+
+## TO DO
+- **Mejor parseo de los errores obtenidos en AFIP**: La idea seria poder identificar cada uno de los errores posibles obtenido, y agregar los errores en la `bill` al atributo que corresponda.
+- **Batch**: Permitir a `Snoopy::AuthorizeAdapter` autorizar un pool de `Snoopy::Bill` en una sola request.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/snoopy_afip/authentication_adapter.rb

@@ -0,0 +1,119 @@
+# coding: utf-8
+module Snoopy
+  class AuthenticationAdapter
+    attr_reader :id, :from, :to, :pkey, :cert, :tra, :cms, :request, :response, :client
+
+    def initialize(attrs={})
+      time = Time.new
+      @id     = time.to_i
+      @from   = time.strftime("%Y-%m-%dT%H:%M:%S%:z")
+      @to     = (time + 86400/2).strftime("%Y-%m-%dT%H:%M:%S%:z") # 86400.seg = 1.day
+      @pkey   = attrs[:pkey]
+      @cert   = attrs[:cert]
+      @client = Snoopy::Client.new(client_configuration)
+    end
+
+    # http://www.afip.gov.ar/ws/WSAA/Especificacion_Tecnica_WSAA_1.2.0.pdf
+    # coe.notAuthorized:          Computador no autorizado a acceder los servicio de AFIP
+    # cms.bad:                    El CMS no es valido
+    # cms.bad.base64:             No se puede decodificar el BASE64
+    # cms.cert.notFound:          No se ha encontrado certificado de firma en el CMS
+    # cms.sign.invalid:           Firma inválida o algoritmo no soportado
+    # cms.cert.expired:           Certificado expirado
+    # cms.cert.invalid:           Certificado con fecha de generación posterior a la actual
+    # cms.cert.untrusted:         Certificado no emitido por AC de confianza
+    # xml.bad:                    No se ha podido interpretar el XML contra el SCHEMA
+    # xml.source.invalid:         El atributo 'source' no se corresponde con el DN del Certificad
+    # xml.destination.invalid:    El atributo 'destination' no se corresponde con el DN del WSAA
+    # xml.version.notSupported:   La versión del documento no es soportada
+    # xml.generationTime.invalid: El tiempo de generación es posterior a la hora actual o posee más de 24 horas de antiguedad
+    # xml.expirationTime.expired: El tiempo de expiración es inferior a la hora actual
+    # xml.expirationTime.invalid: El tiempo de expiración del documento es superior a 24 horas
+    # wsn.unavailable:            El servicio al que se desea acceder se encuentra momentáneamente fuera de servicio
+    # wsn.notFound:               Servicio informado inexistente
+    # wsaa.unavailable:           El servicio de autenticación/autorización se encuentra momentáneamente fuera de servicio
+    # wsaa.internalError:         No se ha podido procesar el requerimiento
+    def authenticate!
+      @response = client.call(:login_cms, :message => { :in0 => build_cms })
+      parser_response.deep_symbolize_keys
+    end
+
+    def parser_response
+      response_credentials.merge( 'expiration_time' => response_header["expirationTime"] )
+    end
+
+    def response_header
+      @_header_response ||= response_to_hash["loginTicketResponse"]["header"]
+    end
+
+    def response_credentials
+      @_credentials ||= response_to_hash["loginTicketResponse"]["credentials"]
+    end
+
+    def response_to_hash
+      @_response_to_hash ||= Nori.new.parse(response[:login_cms_response][:login_cms_return])
+    end
+
+    def self.generate_pkey(leng=8192)
+      begin
+        OpenSSL::PKey::RSA.new(leng).to_pem # %x(openssl genrsa 8192)
+      rescue => e
+        raise "command fail: 'openssl genrsa 8192' error al generar pkey: #{e.message}, error: #{e.message}"
+      end
+    end
+
+    def self.generate_certificate_request_with_ruby(pkey, subj_o, subj_cn, subj_cuit)
+      options = [ ['C',             'AR',                OpenSSL::ASN1::PRINTABLESTRING],
+                  ['O',             subj_o,              OpenSSL::ASN1::UTF8STRING],
+                  ['CN',            subj_cn,             OpenSSL::ASN1::UTF8STRING],
+                  ['serialNumber',  "CUIT #{subj_cuit}", OpenSSL::ASN1::UTF8STRING] ]
+      key = OpenSSL::PKey::RSA.new(File.read(pkey))
+
+      request = OpenSSL::X509::Request.new
+      request.version = 0
+      request.subject = OpenSSL::X509::Name.new(options)
+      request.public_key = key.public_key
+      request.sign(key, OpenSSL::Digest::SHA256.new).to_pem
+    end
+
+    # pkey:      clave privada generada por el metodo generate_pkey.
+    # subj_o:    Nombre de la empresa, registrado en AFIP.
+    # subj_cn:   hostname del servidor que realizara la comunicación con AFIP.
+    # subj_cuit: Cuit registado en AFIP.
+    def self.generate_certificate_request_with_bash(pkey, subj_o, subj_cn, subj_cuit)
+      begin
+        %x(openssl req -new -key #{pkey} -subj "/C=AR/O=#{subj_o}/CN=#{subj_cn}/serialNumber=CUIT #{subj_cuit}")
+      rescue => e
+        raise "command fail: openssl req -new -key #{pkey} -subj /C=AR/O=#{subj_o}/CN=#{subj_cn}/serialNumber=CUIT #{subj_cuit} -out #{out_path}, error: #{e.message}"
+      end
+    end
+
+    def build_tra
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.loginTicketRequest('version' => '1.0') {
+          xml.header {
+            xml.uniqueId id
+            xml.generationTime from
+            xml.expirationTime to
+          }
+          xml.service "wsfe"
+        }
+      end
+      builder.to_xml
+    end
+
+    def build_cms
+      key = OpenSSL::PKey::RSA.new(File.read(pkey))
+      crt = OpenSSL::X509::Certificate.new(File.read(cert))
+      pkcs7 = OpenSSL::PKCS7::sign(crt, key, build_tra)
+      @cms = pkcs7.to_pem.lines.to_a[1..-2].join
+    end
+
+    def client_configuration
+      { :wsdl             => Snoopy.auth_url,
+        :ssl_version      => :TLSv1,
+        :pretty_print_xml => true }
+    end
+  end
+end
+

data/lib/snoopy_afip/authorize_adapter.rb

@@ -0,0 +1,178 @@
+module Snoopy
+  class AuthorizeAdapter
+
+    attr_accessor :bill, :cuit, :sign, :pkey, :cert, :token, :errors, :request, :response, :afip_errors, :afip_events, :afip_observations, :client
+
+    def initialize(attrs)
+      @bill              = attrs[:bill]
+      @cuit              = attrs[:cuit]
+      @sign              = attrs[:sign]
+      @pkey              = attrs[:pkey]
+      @cert              = attrs[:cert]
+      @token             = attrs[:token]
+      @errors            = {}
+      @request           = nil
+      @response          = nil
+      @afip_errors       = {}
+      @afip_events       = {}
+      @afip_observations = {}
+      @client            = Snoopy::Client.new(client_configuration)
+    end
+
+    def auth
+      { "Token" => token, "Sign" => sign, "Cuit" => cuit }
+    end
+
+    def authorize!
+      return false unless bill.valid?
+      set_bill_number!
+      build_body_request
+      @response = client.call( :fecae_solicitar, :message => @request )
+      parse_fecae_solicitar_response
+      !@response.nil?
+    end
+
+    def set_bill_number!
+      message = { "Auth" => auth, "PtoVta" => bill.sale_point, "CbteTipo" => bill.cbte_type }
+      resp = client.call( :fe_comp_ultimo_autorizado, :message =>  message )
+
+      begin
+        resp_errors = resp[:fe_comp_ultimo_autorizado_response][:fe_comp_ultimo_autorizado_result][:errors]
+        resp_errors.each_value { |value| errors[value[:code]] = value[:msg] } unless resp_errors.nil?
+        bill.number = resp[:fe_comp_ultimo_autorizado_response][:fe_comp_ultimo_autorizado_result][:cbte_nro].to_i + 1 if errors.empty?
+      rescue => e
+        raise Snoopy::Exception::AuthorizeAdapter::SetBillNumberParser.new(e.message, e.backtrace)
+      end
+    end
+
+    def build_body_request
+      # today = Time.new.in_time_zone('Buenos Aires').strftime('%Y%m%d')
+      today = Date.today.strftime('%Y%m%d')
+      fecaereq = {"FeCAEReq" => { "FeCabReq" => { "CantReg" => "1", "CbteTipo" => bill.cbte_type, "PtoVta" => bill.sale_point },
+                                  "FeDetReq" => { "FECAEDetRequest" => { "Concepto"   => Snoopy::CONCEPTS[bill.concept],
+                                                                         "DocTipo"    => Snoopy::DOCUMENTS[bill.document_type],
+                                                                         "CbteFch"    => today,
+                                                                         "ImpTotConc" => 0.00,
+                                                                         "MonId"      => Snoopy::CURRENCY[bill.currency][:code],
+                                                                         "MonCotiz"   => bill.exchange_rate,
+                                                                         "ImpOpEx"    => 0.00,
+                                                                         "ImpTrib"    => 0.00 }}}}
+
+      unless bill.issuer_iva_cond.to_sym == Snoopy::RESPONSABLE_MONOTRIBUTO
+        _alicivas = bill.alicivas.collect do |aliciva|
+          { 'Id' => Snoopy::ALIC_IVA[aliciva[:id]], 'Importe' => aliciva[:amount], 'BaseImp' => aliciva[:taxeable_base] }
+        end
+        fecaereq["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"]["Iva"] = { "AlicIva" => _alicivas }
+      end
+
+      detail = fecaereq["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"]
+
+      detail["DocNro"]    = bill.document_num
+      detail["ImpNeto"]   = bill.total_net.to_f
+      detail["ImpIVA"]    = bill.iva_sum
+      detail["ImpTotal"]  = bill.total
+      detail["CbteDesde"] = detail["CbteHasta"] = bill.number
+
+      unless bill.concept == "Productos"
+        detail.merge!({ "FchServDesde" => bill.service_date_from || today,
+                        "FchServHasta" => bill.service_date_to   || today,
+                        "FchVtoPago"   => bill.due_date          || today})
+      end
+
+      if bill.receiver_iva_cond.to_s.include?("nota_credito")
+        detail.merge!({"CbtesAsoc" => {"CbteAsoc" => {"Nro"    => bill.cbte_asoc_num,
+                                                      "PtoVta" => bill.cbte_asoc_to_sale_point,
+                                                      "Tipo"   => bill.cbte_type }}})
+      end
+
+      @request = { "Auth" => auth }.merge!(fecaereq)
+    rescue => e
+      raise Snoopy::Exception::AuthorizeAdapter::BuildBodyRequest.new(e.message, e.backtrace)
+    end
+
+    def parse_observations(fecae_observations)
+      fecae_observations.each_value do |obs|
+        [obs].flatten.each { |ob| afip_observations[ob[:code]] = ob[:msg] }
+      end
+    rescue => e
+      errors << Snoopy::Exception::AuthorizeAdapter::ObservationParser.new(e.message, e.backtrace)
+    end
+
+    def parse_events(fecae_events)
+      fecae_events.each_value do |events|
+        [events].flatten.each { |event| afip_events[event[:code]] = event[:msg] }
+      end
+    rescue => e
+      errors << Snoopy::Exception::AuthorizeAdapter::EventsParser.new(e.message, e.backtrace)
+    end
+
+    def parse_errors(fecae_errors)
+      fecae_errors.each_value do |errores|
+        [errores].flatten.each { |error| afip_errors[error[:code]] = error[:msg] }
+      end
+    rescue => e
+      errors << Snoopy::Exception::AuthorizeAdapter::ErrorParser.new(e.message, e.backtrace)
+    end
+
+    def parse_fecae_solicitar_response
+      begin
+        fecae_result   = response[:fecae_solicitar_response][:fecae_solicitar_result]
+        fecae_response = fecae_result[:fe_det_resp][:fecae_det_response]
+
+        bill.number       = fecae_response[:cbte_desde]
+        bill.cae          = fecae_response[:cae]
+        bill.due_date_cae = fecae_response[:cae_fch_vto]
+        bill.result       = fecae_response[:resultado]
+      rescue => e
+        raise Snoopy::Exception::AuthorizeAdapter::FecaeSolicitarResultParser.new(e.message, e.backtrace)
+      end
+
+      begin
+        bill.voucher_date = fecae_response[:cbte_fch]
+        bill.process_date = fecae_result[:fe_cab_resp][:fch_proceso]
+
+        parse_observations(fecae_response.delete(:observaciones)) if fecae_response.has_key? :observaciones
+        parse_errors(fecae_result[:errors])                       if fecae_result.has_key? :errors
+        parse_events(fecae_result[:events])                       if fecae_result.has_key? :events
+      rescue => e
+        @errors << Snoopy::Exception::AuthorizeAdapter::FecaeResponseParser.new(e.message, e.backtrace)
+      end
+    end
+
+    def parse_fe_comp_consultar_response
+      fe_comp_consultar_result = response[:fe_comp_consultar_response][:fe_comp_consultar_result]
+      result_get               = fe_comp_consultar_result[:result_get]
+
+      unless result_get.nil?
+        bill.result            = result_get[:resultado]
+        bill.number            = result_get[:cbte_desde]
+        bill.cae               = result_get[:cod_autorizacion]
+        bill.due_date_cae      = result_get[:fch_vto]
+        bill.imp_iva           = result_get[:imp_iva]
+        bill.document_num      = result_get[:doc_numero]
+        bill.process_date      = result_get[:fch_proceso]
+        bill.voucher_date      = result_get[:cbte_fch]
+        bill.service_date_to   = result_get[:fch_serv_hasta]
+        bill.service_date_from = result_get[:fch_serv_desde]
+        parse_events(result_get[:observaciones]) if result_get.has_key? :observaciones
+      end
+
+      self.parse_events(fe_comp_consultar_result[:errors]) if fe_comp_consultar_result and fe_comp_consultar_result.has_key? :errors
+      self.parse_events(fe_comp_consultar_result[:events]) if fe_comp_consultar_result and fe_comp_consultar_result.has_key? :events
+    rescue => e
+      @errors << Snoopy::Exception::FecompConsultResponseParser.new(e.message, e.backtrace)
+    end
+
+    def client_configuration
+      { :wsdl              => Snoopy.service_url,
+        :headers           => { "Accept-Encoding" => "gzip, deflate", "Connection" => "Keep-Alive" },
+        :namespaces        => {"xmlns" => "http://ar.gov.afip.dif.FEV1/"},
+        :ssl_version       => :TLSv1,
+        :read_timeout      => 90,
+        :open_timeout      => 90,
+        :ssl_cert_file     => cert,
+        :ssl_cert_key_file => pkey,
+        :pretty_print_xml  => true }
+    end
+  end
+end