bravo 0.4.0 → 1.0.0.alpha

data/lib/bravo/bill.rb

@@ -1,59 +1,80 @@
 module Bravo
+  # The main class in Bravo. Handles WSFE method interactions.
+  # Subsequent implementations will be added here (maybe).
+  #
   class Bill
-    attr_reader :client, :base_imp, :total
+    # Returns the Savon::Client instance in charge of the interactions with WSFE API.
+    # (built on init)
+    #
+    attr_reader :client
+
     attr_accessor :net, :doc_num, :iva_cond, :documento, :concepto, :moneda,
                   :due_date, :aliciva_id, :fch_serv_desde, :fch_serv_hasta,
-                  :body, :response
+                  :body, :response, :invoice_type
 
     def initialize(attrs = {})
       Bravo::AuthData.fetch
-      @client         = Savon::Client.new(Bravo.service_url)
-      @body           = {"Auth" => Bravo.auth_hash}
-      @net            = attrs[:net] || 0
-      self.documento  = attrs[:documento] || Bravo.default_documento
-      self.moneda     = attrs[:moneda]    || Bravo.default_moneda
-      self.iva_cond   = attrs[:iva_cond]
-      self.concepto   = attrs[:concepto]  || Bravo.default_concepto
+      @client           = Savon.client(wsdl: Bravo::AuthData.wsfe_url, log: false)
+      @body             = { "Auth" => Bravo::AuthData.auth_hash }
+      self.iva_cond     = attrs[:iva_cond]
+      @net              = attrs[:net]           || 0
+      self.documento    = attrs[:documento]     || Bravo.default_documento
+      self.moneda       = attrs[:moneda]        || Bravo.default_moneda
+      self.concepto     = attrs[:concepto]      || Bravo.default_concepto
+      self.invoice_type = attrs[:invoice_type]  || :invoice
     end
 
+    # Searches the corresponding invoice type according to the combination of
+    # the seller's IVA condition and the buyer's IVA condition
+    # @return [String] the document type string
+    #
     def cbte_type
-      Bravo::BILL_TYPE[Bravo.own_iva_cond][iva_cond] ||
-        raise(NullOrInvalidAttribute.new, "Please choose a valid document type.")
-    end
+      own_iva = Bravo::BILL_TYPE.has_key?(Bravo.own_iva_cond) ? Bravo::BILL_TYPE[Bravo.own_iva_cond] : raise(NullOrInvalidAttribute.new, "Own iva_cond is invalid.")
+      target_iva = own_iva.has_key?(iva_cond) ? own_iva[iva_cond] : raise(NullOrInvalidAttribute.new, "Target iva_cond is invalid.")
+      type = target_iva.has_key?(invoice_type) ? target_iva[invoice_type] : raise(NullOrInvalidAttribute.new, "Selected invoice_type is invalid.")
 
-    def exchange_rate
-      return 1 if moneda == :peso
-      response = client.fe_param_get_cotizacion do |soap|
-        soap.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
-        soap.body = body.merge!({"MonId" => Bravo::MONEDAS[moneda][:codigo]})
-      end
-      response.to_hash[:fe_param_get_cotizacion_response][:fe_param_get_cotizacion_result][:result_get][:mon_cotiz].to_f
     end
 
+    # Calculates the total field for the invoice by adding
+    # net and iva_sum.
+    # @return [Float] the sum of both fields, or 0 if the net is 0.
+    #
     def total
       @total = net.zero? ? 0 : net + iva_sum
     end
 
+    # Calculates the corresponding iva sum.
+    # This is performed by multiplying the net by the tax value
+    # @return [Float] the iva sum
+    #
+    # TODO: fix this
+    #
     def iva_sum
       @iva_sum = net * Bravo::ALIC_IVA[aliciva_id][1]
       @iva_sum.round_up_with_precision(2)
     end
 
+    # Files the authorization request to AFIP
+    # @return [Boolean] wether the request succeeded or not
+    #
     def authorize
       setup_bill
-      response = client.fecae_solicitar do |soap|
-        soap.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
-        soap.body = body
+      response = client.call(:fecae_solicitar) do |soap|
+        # soap.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
+        soap.message body
       end
 
       setup_response(response.to_hash)
       self.authorized?
     end
 
+    # Sets up the request body for the authorisation
+    # @return [Hash] returns the request body as a hash
+    #
     def setup_bill
       today = Time.new.strftime('%Y%m%d')
 
-      fecaereq = {"FeCAEReq" => {
+      fecaereq = { "FeCAEReq" => {
                     "FeCabReq" => Bravo::Bill.header(cbte_type),
                     "FeDetReq" => {
                       "FECAEDetRequest" => {
@@ -62,14 +83,14 @@ module Bravo
                         "CbteFch"     => today,
                         "ImpTotConc"  => 0.00,
                         "MonId"       => Bravo::MONEDAS[moneda][:codigo],
-                        "MonCotiz"    => exchange_rate,
+                        "MonCotiz"    => 1,
                         "ImpOpEx"     => 0.00,
                         "ImpTrib"     => 0.00,
                         "Iva"         => {
                           "AlicIva" => {
                             "Id" => "5",
                             "BaseImp" => net,
-                            "Importe" => iva_sum}}}}}}
+                            "Importe" => iva_sum } } } } } }
 
       detail = fecaereq["FeCAEReq"]["FeDetReq"]["FECAEDetRequest"]
 
@@ -77,26 +98,20 @@ module Bravo
       detail["ImpNeto"]   = net.to_f
       detail["ImpIVA"]    = iva_sum
       detail["ImpTotal"]  = total
-      detail["CbteDesde"] = detail["CbteHasta"] = next_bill_number
+      detail["CbteDesde"] = detail["CbteHasta"] = Bravo::Reference.next_bill_number(cbte_type)
 
       unless concepto == 0
-        detail.merge!({"FchServDesde" => fch_serv_desde || today,
-                      "FchServHasta"  => fch_serv_hasta || today,
-                      "FchVtoPago"    => due_date       || today})
+        detail.merge!({ "FchServDesde"  => fch_serv_desde || today,
+                        "FchServHasta"  => fch_serv_hasta || today,
+                        "FchVtoPago"    => due_date       || today })
       end
 
       body.merge!(fecaereq)
     end
 
-    def next_bill_number
-      resp = client.fe_comp_ultimo_autorizado do |s|
-        s.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
-        s.body = {"Auth" => Bravo.auth_hash, "PtoVta" => Bravo.sale_point, "CbteTipo" => cbte_type}
-      end
-
-      resp.to_hash[:fe_comp_ultimo_autorizado_response][:fe_comp_ultimo_autorizado_result][:cbte_nro].to_i + 1
-    end
-
+    # Returns the result of the authorization operation
+    # @return [Boolean] the response result
+    #
     def authorized?
       !response.nil? && response.header_result == "A" && response.detail_result == "A"
     end
@@ -104,11 +119,18 @@ module Bravo
     private
 
     class << self
-      def header(cbte_type)#todo sacado de la factura
-        {"CantReg" => "1", "CbteTipo" => cbte_type, "PtoVta" => Bravo.sale_point}
+      # Sets the header hash for the request
+      # @return [Hash]
+      #
+      def header(cbte_type)
+        # todo sacado de la factura
+        { "CantReg" => "1", "CbteTipo" => cbte_type, "PtoVta" => Bravo.sale_point }
       end
     end
 
+    # Response parser. Only works for the authorize method
+    # @return [Struct] a struct with key-value pairs with the response values
+    #
     def setup_response(response)
       # TODO: turn this into an all-purpose Response class
 
@@ -124,18 +146,18 @@ module Bravo
 
       request_detail.merge!(iva)
 
-      response_hash = {:header_result => response_header.delete(:resultado),
-                       :authorized_on => response_header.delete(:fch_proceso),
-                       :detail_result => response_detail.delete(:resultado),
-                       :cae_due_date  => response_detail.delete(:cae_fch_vto),
-                       :cae           => response_detail.delete(:cae),
-                       :iva_id        => request_detail.delete(:id),
-                       :iva_importe   => request_detail.delete(:importe),
-                       :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)
-                       }.merge!(request_header).merge!(request_detail)
+      response_hash = { :header_result => response_header.delete(:resultado),
+                        :authorized_on => response_header.delete(:fch_proceso),
+                        :detail_result => response_detail.delete(:resultado),
+                        :cae_due_date  => response_detail.delete(:cae_fch_vto),
+                        :cae           => response_detail.delete(:cae),
+                        :iva_id        => request_detail.delete(:id),
+                        :iva_importe   => request_detail.delete(:importe),
+                        :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)
+                        }.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)

data/lib/bravo/constants.rb

@@ -1,5 +1,9 @@
 # encoding: utf-8
+# Here we define Hashes
+#
 module Bravo
+  # This constant contains the invoice types mappings between codes and names
+  # used by WSFE.
   CBTE_TIPO = {
     "01"=>"Factura A",
     "02"=>"Nota de Débito A",
@@ -21,19 +25,75 @@ module Bravo
     "64"=>"Liquidacion B"
   }
 
-  CONCEPTOS = {"Productos"=>"01", "Servicios"=>"02", "Productos y Servicios"=>"03"}
+  # Name to code mapping for Sale types.
+  #
+  CONCEPTOS = { "Productos"=>"01", "Servicios"=>"02", "Productos y Servicios"=>"03" }
 
-  DOCUMENTOS = {"CUIT"=>"80", "CUIL"=>"86", "CDI"=>"87", "LE"=>"89", "LC"=>"90", "CI Extranjera"=>"91", "en tramite"=>"92", "Acta Nacimiento"=>"93", "CI Bs. As. RNP"=>"95", "DNI"=>"96", "Pasaporte"=>"94", "Doc. (Otro)"=>"99"}
+  # Name to code mapping for types of documents.
+  #
+  DOCUMENTOS = {
+    "CUIT"=>"80",
+    "CUIL"=>"86",
+    "CDI"=>"87",
+    "LE"=>"89",
+    "LC"=>"90",
+    "CI Extranjera"=>"91",
+    "en tramite"=>"92",
+    "Acta Nacimiento"=>"93",
+    "CI Bs. As. RNP"=>"95",
+    "DNI"=>"96",
+    "Pasaporte"=>"94",
+    "Doc. (Otro)"=>"99" }
 
+  # Currency code and names hash identified by a symbol
+  #
   MONEDAS = {
-    :peso  => {:codigo => "PES", :nombre =>"Pesos Argentinos"},
-    :dolar => {:codigo => "DOL", :nombre =>"Dolar Estadounidense"},
-    :real  => {:codigo => "012", :nombre =>"Real"},
-    :euro  => {:codigo => "060", :nombre =>"Euro"},
-    :oro   => {:codigo => "049", :nombre =>"Gramos de Oro Fino"}
-  }
+    :peso  => { :codigo => "PES", :nombre =>"Pesos Argentinos" },
+    :dolar => { :codigo => "DOL", :nombre =>"Dolar Estadounidense" },
+    :real  => { :codigo => "012", :nombre =>"Real" },
+    :euro  => { :codigo => "060", :nombre =>"Euro" },
+    :oro   => { :codigo => "049", :nombre =>"Gramos de Oro Fino" } }
+
 
+  # Tax percentage and codes according to each iva combination
+  #
   ALIC_IVA = [["03", 0], ["04", 0.105], ["05", 0.21], ["06", 0.27]]
 
-  BILL_TYPE = {:responsable_inscripto => {:responsable_inscripto => "01", :consumidor_final => "06", :exento => "06", :responsable_monotributo => "06"}}
-end
+
+
+  # This hash keeps the codes for A document types by operation
+  #
+  BILL_TYPE_A = {
+    :invoice => "01",
+    :debit   => "02",
+    :credit  => "03" }
+
+  # This hash keeps the codes for A document types by operation
+  #
+  BILL_TYPE_B = {
+    :invoice => "06",
+    :debit   => "07",
+    :credit  => "08" }
+
+  # This hash keeps the different buyer and invoice type mapping corresponding to
+  # the seller's iva condition and invoice kind.
+  # Usage:
+  #   `BILL_TYPE[seller_iva_cond][buyer_iva_cond][invoice_type]` #=> invoice type as string
+  #   `BILL_TYPE[:responsable_inscripto][:responsable_inscripto][:invoice]` #=> "01"
+  #
+  BILL_TYPE = {
+    :responsable_inscripto => {
+      :responsable_inscripto    => BILL_TYPE_A,
+      :consumidor_final         => BILL_TYPE_B,
+      :exento                   => BILL_TYPE_B,
+      :responsable_monotributo  => BILL_TYPE_B } }
+
+  # This hash keeps the set of urls for wsaa and wsfe for production and testing envs
+  #
+  URLS = {
+    :test => { :wsaa => "https://wsaahomo.afip.gov.ar/ws/services/LoginCms",
+               :wsfe => "https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL" },
+
+    :production => { :wsaa => "https://wsaa.afip.gov.ar/ws/services/LoginCms",
+                     :wsfe => "https://servicios1.afip.gov.ar/wsfev1/service.asmx" } }
+end

data/lib/bravo/core_ext/float.rb

@@ -1,7 +1,13 @@
+# Float monkeypatching.
+#
 class Float
+  # Should be removed.
+  #
   def round_with_precision(precision = nil)
     precision.nil? ? round : (self * (10 ** precision)).round / (10 ** precision).to_f
   end
+  # Should be removed.
+  #
   def round_up_with_precision(precision = nil)
     precision.nil? ? round : ((self * (10 ** precision)).round + 1) / (10 ** precision).to_f
   end

data/lib/bravo/core_ext/hash.rb

@@ -1,4 +1,8 @@
+# Methods stolen from ActiveSupport, to avoid requiring the gem as a dependency
 class Hash
+  # Alters the hash, converting it's keys to symbols
+  # @return [Hash]
+  #
   def symbolize_keys!
     keys.each do |key|
       self[(key.to_sym rescue key) || key] = delete(key)
@@ -6,10 +10,16 @@ class Hash
     self
   end unless method_defined?(:symbolize_keys!)
 
+  # Returns a copy of the hash, with it's keys converted to symbols
+  # @return [Hash]
+  #
   def symbolize_keys
     dup.symbolize_keys!
   end unless method_defined?(:symbolize_keys)
 
+  # Alters the hash, converting its keys to underscore strings
+  # @return [Hash]
+  #
   def underscore_keys!
     keys.each do |key|
       self[(key.underscore rescue key) || key] = delete(key)
@@ -17,6 +27,8 @@ class Hash
     self
   end unless method_defined?(:underscore_keys!)
 
+  # Returns a copy of the hash, with it's keys converted to underscore strings
+  # @return [Hash]
   def underscore_keys
     dup.underscore_keys!
   end unless method_defined?(:underscore_keys)

data/lib/bravo/core_ext/string.rb

@@ -1,5 +1,8 @@
-# Stolen from activesupport/lib/active_support/inflector/methods.rb, line 48
+# Added to avoid requiring ActiveSupport as dependency
+#
 class String
+  # Stolen from activesupport/lib/active_support/inflector/methods.rb, line 48
+  #
   def underscore
     word = self.to_s.dup
     word.gsub!(/::/, '/')

data/lib/bravo/reference.rb

@@ -0,0 +1,37 @@
+module Bravo
+  # Class in charge of issuing read requests on the api
+  #
+  class Reference
+    # Fetches the number for the next bill to be issued
+    # @return [Integer] the number for the next bill
+    #
+    def self.next_bill_number(cbte_type)
+      set_client
+      resp = @client.call(:fe_comp_ultimo_autorizado) do |soap|
+        # soap.namespaces["xmlns"] = "http://ar.gov.afip.dif.FEV1/"
+        soap.message "Auth" => Bravo::AuthData.auth_hash, "PtoVta" => Bravo.sale_point, "CbteTipo" => cbte_type
+      end
+
+      resp.to_hash[:fe_comp_ultimo_autorizado_response][:fe_comp_ultimo_autorizado_result][:cbte_nro].to_i + 1
+    end
+
+    # Fetches the possible document codes and names
+    # @return [Hash]
+    #
+    def self.get_custom(operation)
+      set_client
+      resp = @client.call(operation) do |soap|
+        soap.message "Auth" => Bravo::AuthData.auth_hash
+      end
+      resp.to_hash
+    end
+
+    # Sets up the cliet to perform consults to the api
+    #
+    #
+    def self.set_client
+      Bravo::AuthData.fetch
+      @client         = Savon.client(wsdl: Bravo::AuthData.wsfe_url, log: false)
+    end
+  end
+end

data/lib/bravo/version.rb

@@ -1,3 +1,5 @@
 module Bravo
-  VERSION = "0.4.0"
+  # Gem version
+  #
+  VERSION = "1.0.0.alpha"
 end

data/lib/bravo/wsaa.rb

@@ -0,0 +1,96 @@
+# -*- encoding: utf-8 -*-
+module Bravo
+  # Authorization class. Handles interactions wiht the WSAA, to provide
+  # valid key and signature that will last for a day.
+  #
+  class Wsaa
+    # Main method for authentication and authorization.
+    # When successful, produces the yaml file with auth data.
+    #
+    def self.login
+      tra   = build_tra
+      cms   = build_cms(tra)
+      req   = build_request(cms)
+      auth  = call_wsaa(req)
+
+      write_yaml(auth)
+    end
+
+    protected
+    # Builds the xml for the "Ticket de Requerimiento de Acceso"
+    # @return [String] containing the request body
+    #
+    def self.build_tra
+      now = Time.now
+      from = now.strftime("%FT%T%:z")
+      to   = ((now - 120) + (24*60*60)).strftime("%FT%T%:z") # make sure ti will last for 24hs - 2 mins
+      id   = now.strftime("%s")
+      tra  = <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<loginTicketRequest version="1.0">
+  <header>
+    <uniqueId>#{ id }</uniqueId>
+    <generationTime>#{ from }</generationTime>
+    <expirationTime>#{ to }</expirationTime>
+  </header>
+  <service>wsfe</service>
+</loginTicketRequest>
+EOF
+      return tra
+    end
+
+    # Builds the CMS
+    # @return [String] cms
+    #
+    def self.build_cms(tra)
+      cms = `echo '#{ tra }' |
+        #{ Bravo.openssl_bin } cms -sign -in /dev/stdin -signer #{ Bravo.cert } -inkey #{ Bravo.pkey } -nodetach \
+                -outform der |
+        #{ Bravo.openssl_bin } base64 -e`
+      return cms
+    end
+
+    # Builds the CMS request to log in to the server
+    # @return [String] the cms body
+    #
+    def self.build_request(cms)
+      request = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="http://wsaa.view.sua.dvadac.desein.afip.gov">
+  <SOAP-ENV:Body>
+    <ns1:loginCms>
+      <ns1:in0>
+#{ cms }
+      </ns1:in0>
+    </ns1:loginCms>
+  </SOAP-ENV:Body>
+</SOAP-ENV:Envelope>
+XML
+      return request
+    end
+
+    # Calls the WSAA with the request built by build_request
+    # @return [Array] with the token and signature
+    #
+    def self.call_wsaa(req)
+      response = `echo '#{ req }' |
+        curl -k -s -H 'Content-Type: application/soap+xml; action=""' -d @- #{ Bravo::AuthData.wsaa_url }`
+
+      response = CGI::unescapeHTML(response)
+      token = response.scan(/\<token\>(.+)\<\/token\>/).first.first
+      sign  = response.scan(/\<sign\>(.+)\<\/sign\>/).first.first
+      return [token, sign]
+    end
+
+    # Writes the token and signature to a YAML file in the /tmp directory
+    #
+    def self.write_yaml(certs)
+      yml = <<-YML
+token: #{certs[0]}
+sign: #{certs[1]}
+YML
+    `echo '#{ yml }' > /tmp/bravo_#{ Bravo.cuit }_#{ Time.new.strftime('%d_%m_%Y') }.yml`
+    end
+
+  end
+end

data/lib/bravo.rb

@@ -5,23 +5,28 @@ require "savon"
 require "bravo/core_ext/float"
 require "bravo/core_ext/hash"
 require "bravo/core_ext/string"
+
 module Bravo
 
+  # Exception Class for missing or invalid attributes
+  #
   class NullOrInvalidAttribute < StandardError; end
 
+  # Exception Clas for missing or invalid certifficate
+  #
+  class MissingCertificate < StandardError; end
+
   autoload :Authorizer,   "bravo/authorizer"
   autoload :AuthData,     "bravo/auth_data"
   autoload :Bill,         "bravo/bill"
   autoload :Constants,    "bravo/constants"
-
+  autoload :Wsaa,         "bravo/wsaa"
+  autoload :Reference,    "bravo/reference"
 
   extend self
-  attr_accessor :cuit, :sale_point, :service_url, :default_documento, :pkey, :cert,
-    :default_concepto, :default_moneda, :own_iva_cond, :verbose, :auth_url
 
-  def auth_hash
-    {"Token" => Bravo::TOKEN, "Sign"  => Bravo::SIGN, "Cuit"  => Bravo.cuit}
-  end
+  attr_accessor :cuit, :sale_point, :default_documento, :pkey, :cert,
+                :default_concepto, :default_moneda, :own_iva_cond,
+                :verbose, :openssl_bin
 
-  Savon::Request.log = false unless (Bravo.verbose == "true") || (ENV["VERBOSE"] == true)
-end
+end

data/spec/bravo/auth_data_spec.rb

@@ -1,12 +1,13 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "AuthData" do
-  it "should create constants for todays data" do
-    Bravo::AuthData.fetch
-    if RUBY_VERSION >= "1.9"
+  describe ".fetch" do
+    it "creates constants for todays data" do
+      Bravo.constants.should_not include(:TOKEN, :SIGN)
+
+      Bravo::AuthData.fetch
+
       Bravo.constants.should include(:TOKEN, :SIGN)
-    else
-      Bravo.constants.should include("TOKEN", "SIGN")
     end
   end
-end
+end