Class: Arca::WSFeCred

Inherits:
Object
  • Object
show all
Defined in:
lib/arca/wsfecred.rb

Constant Summary collapse

WSDL = 
{
  development: "https://fwshomo.afip.gov.ar/wsfecred/FECredService?wsdl",
  production: "https://serviciosjava.afip.gob.ar/wsfecred/FECredService?wsdl",
  test: "#{Root}/test/fixtures/wsfecred/wsfecred.wsdl"
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ WSFeCred

Returns a new instance of WSFeCred.



19
20
21
22
23
24
25
26
27
 
# File 'lib/arca/wsfecred.rb', line 19

def initialize(options = {})
  @cuit = normalize_cuit(options[:cuit])
  @wsaa = WSAA.new options.merge(service: "wsfecred")
  @client = Client.new Hash(options[:savon]).reverse_merge(
    wsdl: WSDL[@wsaa.env],
    soap_version: 1,
    convert_request_keys_to: :camelcase
  )
end

Instance Attribute Details

#cuit ⇒ Object (readonly)

Returns the value of attribute cuit.



17
18
19
 
# File 'lib/arca/wsfecred.rb', line 17

def cuit
  @cuit
end

#wsaa ⇒ Object (readonly)

Returns the value of attribute wsaa.



17
18
19
 
# File 'lib/arca/wsfecred.rb', line 17

def wsaa
  @wsaa
end

Instance Method Details

#aceptar_f_e_cred(id_cta_cte, **opciones) ⇒ Object

Aceptar o cancelar total/parcialmente la Factura Electrónica de Crédito. id_cta_cte: { cod_cta_cte: long } o { id_factura: { cuit_emisor, cod_tipo_cmp, pto_vta, nro_cmp } } Opciones: array_confirmar_notas_dc, array_formas_cancelacion, array_retenciones, array_ajustes_operacion, tipo_cancelacion, importe_cancelado, importe_total_ret_pesos, importe_embargo_pesos, saldo_aceptado, cod_moneda, cotizacion_moneda_ult, informa_cbu, cbu_comprador



47
48
49
50
51
 
# File 'lib/arca/wsfecred.rb', line 47

def aceptar_f_e_cred id_cta_cte, **opciones
  body = { auth_request: auth, id_cta_cte: build_id_cta_cte(id_cta_cte) }
  body.merge!(opciones_to_aceptar(opciones))
  parse_operacion_response raw_request(:aceptar_f_e_cred, body), :aceptar_f_e_cred
end

#consultar_comprobantes(rol_cuit_representada:, cuit_contraparte: nil, cod_tipo_cmp: nil, estado_cmp: nil, fecha: nil, cod_cta_cte: nil, estado_cta_cte: nil, nro_pagina: nil) ⇒ Object

Consultar comprobantes. rol_cuit_representada: 'Emisor'|'Receptor'. Filtros opcionales.



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/arca/wsfecred.rb', line 118

def consultar_comprobantes(rol_cuit_representada:, cuit_contraparte: nil, cod_tipo_cmp: nil,
  estado_cmp: nil, fecha: nil, cod_cta_cte: nil, estado_cta_cte: nil, nro_pagina: nil)
  body = { auth_request: auth, rol_cuit_representada: rol_cuit_representada }
  body[:cuit_contraparte] = cuit_contraparte if cuit_contraparte
  body[:cod_tipo_cmp] = cod_tipo_cmp if cod_tipo_cmp
  body[:estado_cmp] = estado_cmp if estado_cmp
  body[:fecha] = fecha if fecha
  body[:cod_cta_cte] = cod_cta_cte if cod_cta_cte
  body[:estado_cta_cte] = estado_cta_cte if estado_cta_cte
  body[:nro_pagina] = nro_pagina if nro_pagina
  r = raw_request(:consultar_comprobantes, body)
  ret = get_return_value(r, :consultar_comprobantes)
  parse_response_errores! ret
  {
    array_comprobantes: wrap_array(ret[:array_comprobantes]&.[](:comprobante)),
    nro_pagina: ret[:nro_pagina],
    hay_mas: ret[:hay_mas],
    evento: ret[:evento],
    array_observaciones: wrap_codigo_descripcion(ret[:array_observaciones])
  }
end

#consultar_cta_cte(id_cta_cte) ⇒ Object

Consultar detalle de una cuenta corriente.



162
163
164
165
166
167
168
 
# File 'lib/arca/wsfecred.rb', line 162

def consultar_cta_cte(id_cta_cte)
  body = { auth_request: auth, id_cta_cte: build_id_cta_cte(id_cta_cte) }
  r = raw_request(:consultar_cta_cte, body)
  ret = get_return_value(r, :consultar_cta_cte)
  parse_response_errores! ret
  ret.merge(cta_cte: ret[:cta_cte], array_observaciones: wrap_codigo_descripcion(ret[:array_observaciones]))
end

#consultar_ctas_ctes(rol_cuit_representada:, cuit_contraparte: nil, fecha: nil, estado_cta_cte: nil, nro_pagina: nil, opcion_transferencia: nil) ⇒ Object

Consultar cuentas corrientes. rol_cuit_representada, filtros opcionales.



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/arca/wsfecred.rb', line 141

def consultar_ctas_ctes(rol_cuit_representada:, cuit_contraparte: nil, fecha: nil,
  estado_cta_cte: nil, nro_pagina: nil, opcion_transferencia: nil)
  body = { auth_request: auth, rol_cuit_representada: rol_cuit_representada }
  body[:cuit_contraparte] = cuit_contraparte if cuit_contraparte
  body[:fecha] = fecha if fecha
  body[:estado_cta_cte] = estado_cta_cte if estado_cta_cte
  body[:nro_pagina] = nro_pagina if nro_pagina
  body[:opcion_transferencia] = opcion_transferencia if opcion_transferencia
  r = raw_request(:consultar_ctas_ctes, body)
  ret = get_return_value(r, :consultar_ctas_ctes)
  parse_response_errores! ret
  {
    array_infos_cta_cte: wrap_array(ret[:array_infos_cta_cte]&.[](:info_cta_cte)),
    nro_pagina: ret[:nro_pagina],
    hay_mas: ret[:hay_mas],
    evento: ret[:evento],
    array_observaciones: wrap_codigo_descripcion(ret[:array_observaciones])
  }
end

#consultar_cuentas_en_agt_dpto_cltv ⇒ Object

Consultar cuentas del vendedor en Agentes de Depósito Colectivo.



171
172
173
174
175
176
177
178
179
180
 
# File 'lib/arca/wsfecred.rb', line 171

def consultar_cuentas_en_agt_dpto_cltv
  body = { auth_request: auth }
  r = raw_request(:consultar_cuentas_en_agt_dpto_cltv, body)
  ret = get_return_value(r, :consultar_cuentas_en_agt_dpto_cltv)
  parse_response_errores! ret
  {
    array_cuentas_en_agente: wrap_array(ret[:array_cuentas_en_agente]&.[](:cuenta_en_agente)),
    array_observaciones: wrap_codigo_descripcion(ret[:array_observaciones])
  }
end

#consultar_facturas_agt_dpto_cltv(id_cta_cte: nil, filtro_fecha: nil) ⇒ Object

Facturas informadas al Agente de Depósito Colectivo.



218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/arca/wsfecred.rb', line 218

def consultar_facturas_agt_dpto_cltv(id_cta_cte: nil, filtro_fecha: nil)
  body = { auth_request: auth }
  body[:id_cta_cte] = build_id_cta_cte(id_cta_cte) if id_cta_cte
  body[:filtro_fecha] = filtro_fecha if filtro_fecha
  r = raw_request(:consultar_facturas_agt_dpto_cltv, body)
  ret = get_return_value(r, :consultar_facturas_agt_dpto_cltv)
  parse_response_errores! ret
  {
    array_facturas_agt_dpto_cltv: wrap_array(ret[:array_facturas_agt_dpto_cltv]&.[](:factura_informada)),
    evento: ret[:evento],
    array_observaciones: wrap_codigo_descripcion(ret[:array_observaciones])
  }
end

#consultar_historial_estados_comprobante(id_comprobante) ⇒ Object

Historial de estados de un comprobante.



251
252
253
254
255
256
257
258
259
260
 
# File 'lib/arca/wsfecred.rb', line 251

def consultar_historial_estados_comprobante(id_comprobante)
  body = { auth_request: auth, id_comprobante: build_id_comprobante(id_comprobante) }
  r = raw_request(:consultar_historial_estados_comprobante, body)
  ret = get_return_value(r, :consultar_historial_estados_comprobante)
  parse_response_errores! ret
  {
    id_comprobante: ret[:id_comprobante],
    array_historial_estados: wrap_array(ret[:array_historial_estados]&.[](:estado_historico))
  }
end

#consultar_historial_estados_cta_cte(id_cta_cte) ⇒ Object

Historial de estados de una cuenta corriente.



263
264
265
266
267
268
269
270
271
272
 
# File 'lib/arca/wsfecred.rb', line 263

def consultar_historial_estados_cta_cte(id_cta_cte)
  body = { auth_request: auth, id_cta_cte: build_id_cta_cte(id_cta_cte) }
  r = raw_request(:consultar_historial_estados_cta_cte, body)
  ret = get_return_value(r, :consultar_historial_estados_cta_cte)
  parse_response_errores! ret
  {
    id_cta_cte: ret[:id_cta_cte],
    array_historial_estados: wrap_array(ret[:array_historial_estados]&.[](:estado_historico))
  }
end

#consultar_monto_obligado_recepcion(cuit_consultada:, fecha_emision:) ⇒ Object

Consultar monto obligado recepción para una CUIT y fecha de emisión.



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/arca/wsfecred.rb', line 183

def consultar_monto_obligado_recepcion(cuit_consultada:, fecha_emision:)
  body = {
    auth_request: auth,
    cuit_consultada: normalize_cuit(cuit_consultada),
    fecha_emision: format_date(fecha_emision)
  }
  r = raw_request(:consultar_monto_obligado_recepcion, body)
  ret = get_return_value(r, :consultar_monto_obligado_recepcion)
  parse_response_errores! ret
  {
    respuesta: ret[:respuesta],
    monto_desde: ret[:monto_desde],
    array_observaciones: wrap_codigo_descripcion(ret[:array_observaciones])
  }
end

#consultar_tipos_ajustes_operacion ⇒ Object

Tipos de ajustes de operación.



275
276
277
278
279
280
281
 
# File 'lib/arca/wsfecred.rb', line 275

def consultar_tipos_ajustes_operacion
  body = { auth_request: auth }
  r = raw_request(:consultar_tipos_ajustes_operacion, body)
  ret = get_return_value(r, :consultar_tipos_ajustes_operacion)
  parse_response_errores! ret
  wrap_codigo_descripcion(ret[:array_codigo_descripcion])
end

#consultar_tipos_formas_cancelacion ⇒ Object

Tipos de formas de cancelación.



233
234
235
236
237
238
239
 
# File 'lib/arca/wsfecred.rb', line 233

def consultar_tipos_formas_cancelacion
  body = { auth_request: auth }
  r = raw_request(:consultar_tipos_formas_cancelacion, body)
  ret = get_return_value(r, :consultar_tipos_formas_cancelacion)
  parse_response_errores! ret
  wrap_codigo_descripcion(ret[:array_codigo_descripcion])
end

#consultar_tipos_motivos_rechazo ⇒ Object

Tipos de motivos de rechazo.



209
210
211
212
213
214
215
 
# File 'lib/arca/wsfecred.rb', line 209

def consultar_tipos_motivos_rechazo
  body = { auth_request: auth }
  r = raw_request(:consultar_tipos_motivos_rechazo, body)
  ret = get_return_value(r, :consultar_tipos_motivos_rechazo)
  parse_response_errores! ret
  wrap_codigo_descripcion(ret[:array_codigo_descripcion])
end

#consultar_tipos_retenciones ⇒ Object

Tipos de retenciones habilitados.



200
201
202
203
204
205
206
 
# File 'lib/arca/wsfecred.rb', line 200

def consultar_tipos_retenciones
  body = { auth_request: auth }
  r = raw_request(:consultar_tipos_retenciones, body)
  ret = get_return_value(r, :consultar_tipos_retenciones)
  parse_response_errores! ret
  wrap_array(ret[:array_tipos_retenciones]&.[](:tipo_retencion))
end

#dummy ⇒ Object 



29
30
31
32
33
34
35
36
37
 
# File 'lib/arca/wsfecred.rb', line 29

def dummy
  r = raw_request(:dummy, nil)
  ret = r[:return] || r
  {
    app_server: ret[:appserver] || ret[:app_server],
    auth_server: ret[:authserver] || ret[:auth_server],
    db_server: ret[:dbserver] || ret[:db_server]
  }
end

#informar_cancelacion_total_f_e_cred(id_cta_cte, array_formas_cancelacion:, importe_cancelacion:) ⇒ Object

Informar cancelación total de la FECRED. array_formas_cancelacion: [ { codigo } ], importe_cancelacion

Raises:

  • (ArgumentError) 


93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/arca/wsfecred.rb', line 93

def informar_cancelacion_total_f_e_cred(id_cta_cte, array_formas_cancelacion:, importe_cancelacion:)
  formas = Array(array_formas_cancelacion)
  raise ArgumentError, "array_formas_cancelacion must have at least one item" if formas.empty?

  body = {
    auth_request: auth,
    id_cta_cte: build_id_cta_cte(id_cta_cte),
    array_formas_cancelacion: { codigo_descripcion: formas },
    importe_cancelacion: importe_cancelacion
  }
  parse_operacion_response raw_request(:informar_cancelacion_total_f_e_cred, body),
                           :informar_cancelacion_total_f_e_cred
end

#informar_factura_agt_dpto_cltv(id_cta_cte, cta_agente:) ⇒ Object

Informar Factura al Agente de Depósito Colectivo. cta_agente: { cuit_agente, id_cuenta }



83
84
85
86
87
88
89
90
 
# File 'lib/arca/wsfecred.rb', line 83

def informar_factura_agt_dpto_cltv(id_cta_cte, cta_agente:)
  body = {
    auth_request: auth,
    id_cta_cte: build_id_cta_cte(id_cta_cte),
    cta_agente: cta_agente
  }
  parse_operacion_response raw_request(:informar_factura_agt_dpto_cltv, body), :informar_factura_agt_dpto_cltv
end

#modificar_opcion_transferencia(id_cta_cte, opcion_transferencia:) ⇒ Object

Modificar opción de transferencia (ADC o SCA). opcion_transferencia: 'ADC' | 'SCA'



108
109
110
111
112
113
114
115
 
# File 'lib/arca/wsfecred.rb', line 108

def modificar_opcion_transferencia(id_cta_cte, opcion_transferencia:)
  body = {
    auth_request: auth,
    id_cta_cte: build_id_cta_cte(id_cta_cte),
    opcion_transferencia: opcion_transferencia
  }
  parse_operacion_response raw_request(:modificar_opcion_transferencia, body), :modificar_opcion_transferencia
end

#obtener_remitos(id_comprobante) ⇒ Object

Remitos asociados a un comprobante.



242
243
244
245
246
247
248
 
# File 'lib/arca/wsfecred.rb', line 242

def obtener_remitos(id_comprobante)
  body = { auth_request: auth, id_comprobante: build_id_comprobante(id_comprobante) }
  r = raw_request(:obtener_remitos, body)
  ret = get_return_value(r, :obtener_remitos)
  parse_response_errores! ret
  wrap_array(ret[:array_ids_remitos]&.[](:id_comprobante))
end

#rechazar_f_e_cred(id_cta_cte, array_motivos_rechazo:) ⇒ Object

Rechazar la Cta.Cte. de una FECRED. array_motivos_rechazo: [ { cod_motivo, desc_motivo, justificacion } ]

Raises:

  • (ArgumentError) 


54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/arca/wsfecred.rb', line 54

def rechazar_f_e_cred(id_cta_cte, array_motivos_rechazo:)
  motivos = Array(array_motivos_rechazo)
  raise ArgumentError, "array_motivos_rechazo must have at least one motive" if motivos.empty?

  body = {
    auth_request: auth,
    id_cta_cte: build_id_cta_cte(id_cta_cte),
    array_motivos_rechazo: { motivo_rechazo: motivos }
  }
  parse_operacion_response raw_request(:rechazar_f_e_cred, body), :rechazar_f_e_cred
end

#rechazar_nota_dc(id_comprobante, array_motivos_rechazo:) ⇒ Object

Rechazar una Nota de Débito/Crédito individualmente.

Raises:

  • (ArgumentError) 


67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/arca/wsfecred.rb', line 67

def rechazar_nota_dc(id_comprobante, array_motivos_rechazo:)
  motivos = Array(array_motivos_rechazo)
  raise ArgumentError, "array_motivos_rechazo must have at least one motive" if motivos.empty?

  body = {
    auth_request: auth,
    id_comprobante: build_id_comprobante(id_comprobante),
    array_motivos_rechazo: { motivo_rechazo: motivos }
  }
  r = raw_request(:rechazar_nota_dc, body)
  ret = get_return_value(r, :rechazar_nota_dc)
  parse_response_errores! ret
  ret
end