Permite realizar la inscripción del tarjetahabiente e información de su
tarjeta de crédito. Retorna como respuesta un token que representa la transacción de inscripción
y una URL (UrlWebpay),que corresponde a la URL de inscripción de One Click
358492
public function initInscription($username, $email, $urlReturn) {

        try {
            $error = array();

            $oneClickInscriptionInput = new oneClickInscriptionInput();

            /** nombre de usuario */
            $oneClickInscriptionInput->username = $username;

            /** email */
            $oneClickInscriptionInput->email = $email;

            /** url de respuesta */
            $oneClickInscriptionInput->responseURL = $urlReturn;

            $initInscriptionResponse = $this->_initInscription(
                    array("oneClickInscriptionInput" => $oneClickInscriptionInput)
            );

            /** Validación de firma del requerimiento de respuesta enviado por Webpay */
            $xmlResponse = $this->soapClient->__getLastResponse();
            $soapValidation = new SoapValidation($xmlResponse, $this->config->getWebpayCert());
            $validationResult = $soapValidation->getValidationResult();

            /** Valida conexion a Webpay. Caso correcto retorna URL y Token */
            if ($validationResult === TRUE) {

                $oneClickInscriptionOutput = $initInscriptionResponse->return;
                return $oneClickInscriptionOutput;

            } else {

                $error["error"] = "Error validando conexi&oacute;n a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";
                $error["detail"] = "No se pudo completar la conexi&oacute;n con Webpay";
            }
        } catch (\Exception $e) {

            $error["error"] = "Error conectando a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";

            $replaceArray = array('<!--' => '', '-->' => '');
            $error["detail"] = str_replace(array_keys($replaceArray), array_values($replaceArray), $e->getMessage());
        }

        return $error;
    }
916240
def CrearAjusteBase(self, 
               pto_emision=1, nro_orden=None,       # unificado, contrato, papel
               coe_ajustado=None,                   # unificado
               nro_contrato=None,                   # contrato
               tipo_formulario=None,                # papel
               nro_formulario=None,                 # papel
               actividad=None,                      # contrato / papel
               cod_grano=None,                      # contrato / papel
               cuit_vendedor=None,                  # contrato / papel
               cuit_comprador=None,                 # contrato / papel
               cuit_corredor=None,                  # contrato / papel
               nro_ing_bruto_vendedor=None,         # papel
               nro_ing_bruto_comprador=None,        # papel
               nro_ing_bruto_corredor=None,         # papel
               tipo_operacion=None,                 # papel
               precio_ref_tn=None,                  # contrato
               cod_grado_ent=None,                  # contrato
               val_grado_ent=None,                  # contrato
               precio_flete_tn=None,                # contrato
               cod_puerto=None,                     # contrato
               des_puerto_localidad=None,           # contrato
               cod_provincia=None,                  # unificado, contrato, papel
               cod_localidad=None,                  # unificado, contrato, papel
               comision_corredor=None,              # papel
               **kwargs
               ):
        ""

        # ajusto nombre de campos para compatibilidad hacia atrás (encabezado):
        if 'cod_localidad_procedencia' in kwargs:
            cod_localidad = kwargs['cod_localidad_procedencia']
        if 'cod_provincia_procedencia' in kwargs:
            cod_provincia = kwargs['cod_provincia_procedencia']
        if 'nro_act_comprador' in kwargs:
            actividad = kwargs['nro_act_comprador']
        if 'cod_tipo_operacion' in kwargs:
            tipo_operacion = kwargs['cod_tipo_operacion']
            
        # limpio los campos especiales (segun validaciones de AFIP)
        if val_grado_ent == 0:
            val_grado_ent = None
        # borrando datos si no corresponden
        if cuit_corredor and int(cuit_corredor) == 0:
            cuit_corredor = None
            comision_corredor = None
            nro_ing_bruto_corredor = None
               
        if cod_puerto and int(cod_puerto) != 14:
            des_puerto_localidad = None             # validacion 1630

        # limpio los campos opcionales para no enviarlos si no corresponde:
        if cod_grado_ent == "":
            cod_grado_ent = None
        if val_grado_ent == 0:
            val_grado_ent = None

        # creo el diccionario con los campos generales del ajuste base:
        self.ajuste = { 'ajusteBase': {
                            'ptoEmision': pto_emision,
                            'nroOrden': nro_orden,
                            'coeAjustado': coe_ajustado,
                            'nroContrato': nro_contrato,
                            'tipoFormulario': tipo_formulario,
                            'nroFormulario': nro_formulario,
                            'actividad': actividad,
                            'codGrano': cod_grano,
                            'cuitVendedor': cuit_vendedor,
                            'cuitComprador': cuit_comprador,
                            'cuitCorredor': cuit_corredor,
                            'nroIngBrutoVendedor': nro_ing_bruto_vendedor,
                            'nroIngBrutoComprador': nro_ing_bruto_comprador,
                            'nroIngBrutoCorredor': nro_ing_bruto_corredor,
                            'tipoOperacion': tipo_operacion,
                            'codPuerto': cod_puerto,
                            'desPuertoLocalidad': des_puerto_localidad,
                            'comisionCorredor': comision_corredor,
                            'precioRefTn': precio_ref_tn,
                            'codGradoEnt': cod_grado_ent,
                            'valGradoEnt': val_grado_ent,
                            'precioFleteTn': precio_flete_tn,
                            'codLocalidad': cod_localidad,
                            'codProv': cod_provincia,
                            'certificados': [],
                            }
                        }
        # para compatibilidad con AgregarCertificado
        self.liquidacion = self.ajuste['ajusteBase']
        # inicializar temporales
        self.__ajuste_base = None
        self.__ajuste_debito = None
        self.__ajuste_credito = None
        return True
1205269
def ConsultarTiposComprobante(self, sep="||"):
        ""
        ret = self.client.consultarTiposComprobante(
                            authRequest={
                                'token': self.Token, 'sign': self.Sign,
                                'cuitRepresentada': self.Cuit, },
                                )['consultarTiposComprobanteReturn']
        self.__analizar_errores(ret)
        array = ret.get('arrayTiposComprobante', [])
        lista = [it['codigoDescripcion'] for it in array]
        return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista]
554122
def ConsultarGastos(self, sep="||"):
        ""
        ret = self.client.consultarGastos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('gasto', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
1088139
def AnalizarLiquidacion(self, liq):
        ""
        # proceso los datos básicos de la liquidación (devuelto por consultar):
        if liq:
            cab = liq['cabecera']
            self.CAE = str(cab['cae'])
            self.FechaLiquidacion = cab['fechaLiquidacion']
            self.NroComprobante = cab['nroComprobante']
            tot = liq['totalesOperacion']
            self.AlicuotaIVA = tot['alicuotaIVA']
            self.ImporteNeto = tot['importeNeto']
            self.ImporteIVA = tot['importeIVA']
            self.Subtotal = tot['subtotal']
            self.TotalRetenciones = tot['totalRetenciones']
            self.TotalTributos = tot['totalTributos']
            self.Total = tot['total']

            # parámetros de salida:
            self.params_out = dict(
                tipo_cbte=liq['cabecera']['tipoComprobante'],
                pto_vta=liq['cabecera']['puntoVenta'],
                nro_cbte=liq['cabecera']['nroComprobante'],
                fecha=liq['cabecera']['fechaLiquidacion'],
                cod_deposito_acopio=liq['cabecera']['codDepositoAcopio'],
                cae=str(liq['cabecera']['cae']),
                domicilio_punto_venta=liq['cabecera']['domicilioPuntoVenta'],
                domicilio_deposito_acopio=liq['cabecera']['domicilioDepositoAcopio'],
                emisor=dict(
                    cuit=liq['emisor']['cuit'],
                    razon_social=liq['emisor']['razonSocial'],
                    situacion_iva=liq['emisor']['situacionIVA'],
                    domicilio=liq['emisor']['domicilio'],
                    fecha_inicio_actividad=liq['emisor']['fechaInicioActividad'],
                    ),
                receptor=dict(
                    cuit=liq['receptor']['cuit'],
                    razon_social=liq['receptor']['razonSocial'],
                    nro_fet=liq['receptor'].get('nroFET'),
                    nro_socio=liq['receptor'].get('nroSocio'),
                    situacion_iva=liq['receptor']['situacionIVA'],
                    domicilio=liq['receptor']['domicilio'],
                    iibb=liq['receptor'].get('iibb'),
                    ),
                control=liq['datosOperacion'].get('control'),
                nro_interno=liq['datosOperacion'].get('nroInterno'),
                condicion_venta=liq['datosOperacion'].get('condicionVenta'),
                variedad_tabaco=liq['datosOperacion']['variedadTabaco'],
                puerta=liq['datosOperacion'].get('puerta'),
                nro_tarjeta=liq['datosOperacion'].get('nroTarjeta'),
                horas=liq['datosOperacion'].get('horas'),
                cod_provincia_origen_tabaco=liq['datosOperacion'].get('codProvinciaOrigenTabaco'),
                tipo_compra=liq['datosOperacion'].get('tipoCompra'),
                peso_total_fardos_kg=liq['detalleOperacion']['pesoTotalFardosKg'],
                cantidad_total_fardos=liq['detalleOperacion']['cantidadTotalFardos'],
                romaneos=[],
                alicuota_iva=liq['totalesOperacion']['alicuotaIVA'],
                importe_iva=liq['totalesOperacion']['importeIVA'],
                importe_neto=liq['totalesOperacion']['importeNeto'],
                subtotal=liq['totalesOperacion']['subtotal'],
                total_retenciones=liq['totalesOperacion']['totalRetenciones'],
                total_tributos=liq['totalesOperacion']['totalTributos'],
                total=liq['totalesOperacion']['total'],
                retenciones=[],
                tributos=[],               
                cae_ajustado=liq.get("caeAjustado"),
                pdf=liq.get('pdf'),
                )
            for romaneo in liq['detalleOperacion'].get('romaneo', []):
                self.params_out['romaneos'].append(dict(
                    fecha_romaneo=romaneo['fechaRomaneo'],
                    nro_romaneo=romaneo['nroRomaneo'],
                    detalle_clase=[dict(
                        cantidad_fardos=det['cantidadFardos'],
                        cod_clase=det['codClase'],
                        importe=det['importe'],
                        peso_fardos_kg=det['pesoFardosKg'],
                        precio_x_kg_fardo=det['precioXKgFardo'],
                        ) for det in romaneo['detalleClase']],
                    ))
            for ret in liq.get('retencion', []):
                self.params_out['retenciones'].append(dict(
                    retencion_codigo=ret['codigo'],
                    retencion_importe=ret['importe'],
                    ))
            for trib in liq.get('tributo',[]):
                self.params_out['tributos'].append(dict(
                    tributo_descripcion=trib.get('descripcion', ""),
                    tributo_base_imponible=trib['baseImponible'],
                    tributo_alicuota=trib['alicuota'],
                    tributo_codigo=trib['codigo'],
                    tributo_importe=trib['importe'],
                    ))
            if DEBUG:
                import pprint
                pprint.pprint(self.params_out)
        self.params_out['errores'] = self.errores
29367
def ConsultarOtrosImpuestos(self, sep="||"):
        ""
        ret = self.client.consultarOtrosImpuestos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('otroImpuesto', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
758562
def GenerarRemito(self, id_req, archivo="qr.png"):
        ""
        if not self.remito['arrayContingencias']:
            del self.remito['arrayContingencias']
        response = self.client.generarRemito(
                                authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit},
                                idReq=id_req, remito=self.remito) 
        ret = response.get("generarRemitoReturn")
        if ret:
            self.__analizar_errores(ret)
            self.__analizar_observaciones(ret)
            self.__analizar_evento(ret)
            self.AnalizarRemito(ret, archivo)
        return bool(self.CodRemito)
1080676
def AnularRemito(self):
        ""
        response = self.client.anularRemito(
                                authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit},
                                codRemito=self.remito['codRemito'])
        ret = response.get("anularRemitoReturn")
        if ret:
            self.__analizar_errores(ret)
            self.__analizar_observaciones(ret)
            self.__analizar_evento(ret)
            self.AnalizarRemito(ret)
        return bool(self.CodRemito)
706766
def ConsultarCertificacion(self, pto_emision=None, nro_orden=None, 
                                     coe=None, pdf=None):
        ""
        if coe:
            ret = self.client.cgConsultarXCoe(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        pdf='S' if pdf else 'N',
                        )
        else:
            ret = self.client.cgConsultarXNroOrden(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        ptoEmision=pto_emision,
                        nroOrden=nro_orden,
                        )
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        if 'autorizacion' in ret:
            self.AnalizarAutorizarCertificadoResp(ret)
        # guardo el PDF si se indico archivo y vino en la respuesta:
        if pdf and 'pdf' in ret:
            open(pdf, "wb").write(ret['pdf'])
        return True
316092
def ConfirmarDefinitivo(self, numero_carta_de_porte, numero_ctg, 
                            establecimiento=None, codigo_cosecha=None, peso_neto_carga=None, 
                            **kwargs):
        ""
        ret = self.client.confirmarDefinitivo(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        datosConfirmarDefinitivo=dict(
                            cartaPorte=numero_carta_de_porte, 
                            ctg=numero_ctg,
                            establecimiento=establecimiento,
                            codigoCosecha=codigo_cosecha,
                            pesoNeto=peso_neto_carga,
                            )))['response']
        self.__analizar_errores(ret)
        datos = ret.get('datosResponse')
        if datos:
            self.CartaPorte = str(datos['cartaPorte'])
            self.NumeroCTG = str(datos['ctg'])
            self.FechaHora = str(datos['fechaHora'])
            self.CodigoTransaccion = str(datos.get('codigoOperacion', ""))
            self.Observaciones = ""
        return self.CodigoTransaccion
75410
def AnalizarAjusteDebito(self):
        ""
        # para compatibilidad con la generacion de PDF (completo datos)
        liq = {}
        if hasattr(self, "liquidacion") and self.liquidacion:
            liq.update(self.liquidacion)
        if hasattr(self, "ajuste") and 'ajusteDebito' in self.ajuste:
            liq.update(self.ajuste['ajusteDebito'])
        if self.__ajuste_debito:
            liq.update(self.__ajuste_debito)
            self.AnalizarLiquidacion(aut=self.__ajuste_debito, liq=liq, ajuste=True)
            self.AnalizarAjuste(self.__ajuste_base, base=False)  # datos generales
        return True
508240
def to_request
      transacao = {
        numero_transacao:               self.numero_transacao,
        "IP" =>                         self.ip,
        codigo_forma_pagamento:         self.codigo_forma_pagamento,
        valor:                          self.valor,
        valor_desconto:                 self.valor_desconto,
        taxa_embarque:                  self.taxa_embarque,
        parcelas:                       self.parcelas,
        nome_titular_cartao_credito:    self.nome_titular_cartao_credito,
        numero_cartao_credito:          self.numero_cartao_credito,
        codigo_seguranca:               self.codigo_seguranca,
        data_validade_cartao:           self.data_validade_cartao,
        vencimento_boleto:              self.vencimento_boleto,
        url_redirecionamento_pago:      self.url_redirecionamento_pago,
        url_redirecionamento_nao_pago:  self.url_redirecionamento_nao_pago,
        campo_livre1:                   self.campo_livre1,
        campo_livre2:                   self.campo_livre2,
        campo_livre3:                   self.campo_livre3,
        campo_livre4:                   self.campo_livre4,
        campo_livre5:                   self.campo_livre5,
      }

      # Adicionar os parâmetros de configurações
      transacao.merge! SuperpayApi.configuracoes_to_request

      # Adicionar dados do usuário
      transacao[:dados_usuario_transacao] = self.dados_usuario_transacao.to_request unless self.dados_usuario_transacao.blank?

      # Adicionar itens do pedido
      transacao[:itens_do_pedido] = self.itens_do_pedido.collect{ |i| i.to_request } unless self.itens_do_pedido.blank?

      return transacao
    end
257117
def AnalizarAjusteCredito(self):
        ""
        liq = {}
        if hasattr(self, "liquidacion") and self.liquidacion:
            liq.update(self.liquidacion)
        if hasattr(self, "ajuste") and 'ajusteCredito' in self.ajuste:
            liq.update(self.ajuste['ajusteCredito'])
        if self.__ajuste_credito:
            liq.update(self.__ajuste_credito)
            self.AnalizarLiquidacion(aut=self.__ajuste_credito, liq=liq, ajuste=True)
            self.AnalizarAjuste(self.__ajuste_base, base=False)  # datos generales
        return True
1028957
def AgregarCompraAsociada(self, tipo_cbte, pto_vta, nro_cbte, cant_asoc, nro_item):
        ""
        d = {'tipoComprobante': tipo_cbte, 
             'puntoVenta': pto_vta,
             'nroComprobante': nro_cbte, 
             'nroItem': nro_item,
             'cantidadAsociada': cant_asoc}
        if 'itemDetalleLiquidacion' in self.solicitud:
            item_liq = self.solicitud['itemDetalleLiquidacion'][-1]
            item_liq['liquidacionCompraAsociada'].append(d)
        else:
            item_liq = self.solicitud['itemDetalleAjusteLiquidacion'][-1]
            item_liq['ajusteCompraAsociada'].append(d)
        return True
1120274
def ConsultarCTGRechazados(self):
        ""
        ret = self.client.consultarCTGRechazados(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                            ))['response']
        self.__analizar_errores(ret)
        datos = ret.get('arrayConsultarCTGRechazados')
        if datos:
            self.DatosCTG = datos
            self.LeerDatosCTG(pop=False)
            return True
        else:
            self.DatosCTG = []
        return False
1065963
def AnalizarLiquidacion(self, liq):
        ""
        # proceso los datos básicos de la liquidación (devuelto por consultar):
        cab = liq.get('cabecera')
        if cab:
            self.CAE = str(cab.get('cae', ''))
            self.FechaVencimientoCae = str(cab.get('fechaVencimientoCae', ''))
            self.FechaProcesoAFIP = str(cab.get('fechaProcesoAFIP', ''))
            self.NroCodigoBarras =  cab.get('nroCodigoBarras')
            datos = liq.get('datosLiquidacion', {})
            self.FechaComprobante = str(datos.get('fechaComprobante', ''))
            emisor = liq.get('emisor', {})
            self.NroComprobante = emisor.get('nroComprobante')
            tot = liq.get('resumenTotales', {})
            self.ImporteBruto = tot.get('importeBruto')
            self.ImporteTotalGastos = tot.get('importeTotalGastos')
            self.ImporteTotalTributos = tot.get('importeTotalTributos')
            self.ImporteTotalNeto = tot.get('importeTotalNeto')
            self.ImporteIVASobreBruto = tot.get('importeIVASobreBruto')
            self.ImporteIVASobreGastos = tot.get('importeIVASobreGastos')
            receptor = liq.get('receptor', {})

            # parámetros de salida:
            self.params_out = dict(
                tipo_cbte=emisor.get('tipoComprobante'),
                pto_vta=emisor.get('puntoVenta'),
                nro_cbte=emisor.get('nroComprobante'),
                fecha=datos.get('fechaComprobante'),
                cae=cab.get('cae'),
                emisor=dict(
                    razon_social=emisor.get('razonSocial'),
                    domicilio_punto_venta=emisor.get('domicilioPuntoVenta'),
                    ),
                receptor=dict(
                    nombre=receptor.get('nombre'),
                    domicilio=receptor.get('domicilio'),
                    ),
                bruto=tot.get('importeBruto'),
                iva_bruto=tot.get('importeIVASobreBruto'),
                iva_gastos=tot.get('importeIVASobreGastos'),
                total_neto=tot.get('importeTotalNeto'),
                total_tributos=tot.get('importeTotalTributos'),
                total_gastos=tot.get('importeTotalGastos'),
                gasto=[],
                guia=[],
                tributo=[],
                pdf=liq.get('pdf'),
                )
            for ret in liq.get('gasto', []):
                self.params_out['gasto'].append(dict(
                    cod_gasto=ret['codGasto'],
                    importe=ret['importe'],
                    ))
            for trib in liq.get('tributo',[]):
                self.params_out['tributo'].append(dict(
                    descripcion=trib.get('descripcion', ""),
                    base_imponible=trib.get('baseImponible'),
                    alicuota=trib.get('alicuota'),
                    codigo=trib['codTributo'],
                    importe=trib['importe'],
                    ))
            # analizar datos del ajuste generado:
            ajuste = liq.get('ajuste', {})
            if ajuste:
                self.params_out.update(dict(
                    tipo_ajuste=ajuste['tipoAjuste'],
                    modo_ajuste=ajuste['modoAjuste'],
                    ))
                ajustado = ajuste.get('comprobanteAjustado')
                if ajustado:
                    self.params_out.update(dict(
                        cbte_ajuste=dict(
                            tipo_cbte=ajustado['tipoComprobante'],
                            pto_vta=ajustado['puntoVenta'],
                            nro_cbte=ajustado['nroComprobante'],
                            )
                        ))
            if DEBUG:
                import pprint
                pprint.pprint(self.params_out)
        self.params_out['errores'] = self.errores
129534
def ConsultarTipoActividad(self, sep="||"):
        ""
        ret = self.client.tipoActividadConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
        self.__analizar_errores(ret)
        array = ret.get('tiposActividad', [])
        return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]