Devuelve los certificados de depósito en los que un productor tiene
        saldo disponible para Liquidar/Retirar/Transferir
974759
def BuscarCertConSaldoDisponible(self, cuit_depositante=None,
                        cod_grano=2, campania=1314, coe=None, 
                        fecha_emision_des=None,
                        fecha_emision_has=None,
                 ):
        """"""
        
        ret = self.client.cgBuscarCertConSaldoDisponible(
                    auth={
                        'token': self.Token, 'sign': self.Sign,
                        'cuit': self.Cuit, },
                    cuitDepositante=cuit_depositante or self.Cuit,
                    codGrano=cod_grano, campania=campania,
                    coe=coe,
                    fechaEmisionDes=fecha_emision_des,
                    fechaEmisionHas=fecha_emision_has,
                        )['oReturn']
        self.__analizar_errores(ret)
        array = ret.get('certificado', [])
        self.Excepcion = self.Traceback = ""
        self.params_out['certificados'] = []
        for cert in array:
            self.params_out['certificados'].append(dict(
                coe=cert['coe'],
                tipo_certificado=cert['tipoCertificado'],
                campania=cert['campania'],
                cuit_depositante=cert['cuitDepositante'],
                cuit_depositario=cert['cuitDepositario'],
                nro_planta=cert['nroPlanta'],
                kilos_disponibles=cert['kilosDisponibles'],
                cod_grano=cert['codGrano'],
            ))
        return True
1301160
public function reverseTransaction($buyOrder) {

        try {

            $oneClickReverseInput = new oneClickReverseInput();

            $oneClickReverseInput->buyorder = $buyOrder;

            $codeReverseOneClickResponse = $this->_codeReverseOneClick(
                    array("oneClickReverseInput" => $oneClickReverseInput)
            );

            /** 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();

            if ($validationResult === TRUE) {

                $oneClickReverseOutput = $codeReverseOneClickResponse->return;
                return $oneClickReverseOutput;

            } 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());

        }
    }
58637
def comunicar_certificado_icpbrasil(self, certificado):
        
        retorno = super(ClienteSATLocal, self).\
                comunicar_certificado_icpbrasil(certificado)
        return RespostaSAT.comunicar_certificado_icpbrasil(retorno)
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]
1232142
function queryShare($token, $buyOrder, $shareNumber) {

        try {

            $queryShare = new queryShare();

            $queryShare->token = $token;
            $queryShare->buyOrder = $buyOrder;
            $queryShare->shareNumber = $shareNumber;

            $queryShareResponse = $this->_queryShare($queryShare);

            $xmlResponse = $this->soapClient->__getLastResponse();
            $soapValidation = new SoapValidation($xmlResponse, $this->config->getWebpayCert());
            $validationResult = $soapValidation->getValidationResult();

            if ($validationResult === TRUE) {

                $wsCompleteQuerySharesOutput = $queryShareResponse->return;
                return $wsCompleteQuerySharesOutput;

            } 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;
    }
595786
def ConsultarUltNroOrden(self, pto_emision=1):
        ""
        ret = self.client.liquidacionUltimoNroOrdenConsultar(
                    auth={
                        'token': self.Token, 'sign': self.Sign,
                        'cuit': self.Cuit, },
                    ptoEmision=pto_emision,
                    )
        ret = ret['liqUltNroOrdenReturn']
        self.__analizar_errores(ret)
        self.NroOrden = ret['nroOrden']
        return True
324460
function _normalizeValidate (field) {
  if (field.validate) {
    Object.keys(field.validate).forEach(key => {
      let validateItem = field.validate[key]
      if (typeof validateItem === 'function') { return }
      // Adiciona la propiedad args, si el validador no lo tuviera.
      // Ejemplo:    min: 10   ->   min: { args: 10 }           isInt: true    ->    isInt: { args: true }
      if ((typeof validateItem !== 'object') || (typeof validateItem.args === 'undefined')) {
        field.validate[key] = { args: validateItem }
      }
      // Convierte los validadores booleanos:    isInt: { args: true }   ->    isInt: true
      // Sequelize no admite validateKey: { args: true }, es por eso que si existe, ésta se elimina.
      if (typeof field.validate[key].args === 'boolean') {
        delete field.validate[key].args
        if (typeof field.validate[key].msg === 'undefined') {
          field.validate[key] = true
        }
      }
      // Corrige el problema cuando se declaran args con valores de 0 y 1.
      // Se corrige porque Sequelize los toma como valores booleanos, cuando debería tomarlos como números enteros.
      // Ejemplo:     min: { args: 0 }  ->   min: { args: [0] }    y   min: { args: 1 }  ->   min: { args: [1] }
      if ((typeof field.validate[key].args !== 'undefined') && ((field.validate[key].args === 0) || (field.validate[key].args === 1))) {
        field.validate[key].args = [field.validate[key].args]
      }
    })
  }
}
77075
def ConsultarTiposComprobante(self, sep="||"):
        ""
        ret = self.client.consultarTiposComprobante(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('tipoComprobante', [])
        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]
219883
def AutorizarLiquidacion(self):
        ""
        # limpio los elementos que no correspondan por estar vacios:
        for campo in ["guia", "dte", "gasto", "tributo"]:
            if campo in self.solicitud and not self.solicitud[campo]:
                del self.solicitud[campo]
        for item in self.solicitud['itemDetalleLiquidacion']:
            if not item.get("liquidacionCompraAsociada", True):
                del item["liquidacionCompraAsociada"]
        # llamo al webservice:
        ret = self.client.generarLiquidacion(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        solicitud=self.solicitud,
                        )
        # analizo la respusta
        ret = ret['respuesta']
        self.__analizar_errores(ret)
        self.AnalizarLiquidacion(ret)
        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
39673
function getTransactionResult($token) {

        try {

            $getTransactionResult = new getTransactionResult();
            $getTransactionResult->tokenInput = $token;
            $getTransactionResultResponse = $this->_getTransactionResult($getTransactionResult);

            /** 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();

            if ($validationResult === TRUE) {

                $transactionResultOutput = $getTransactionResultResponse->return;

                /** Indica a Webpay que se ha recibido conforme el resultado de la transacción */
                if ($this->acknowledgeTransaction($token)) {

                    return $transactionResultOutput;

                } 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());
        }
    }
1131785
function nullify($authorizationCode, $authorizedAmount, $buyOrder, $nullifyAmount, $commercecode) {

        try {
            $nullificationInput = new nullificationInput();

            /** Código de autorización de la transacción que se requiere anular. Para el caso que se esté anulando una transacción de captura en línea,
             *  este código corresponde al código de autorización de la captura */
            $nullificationInput->authorizationCode = $authorizationCode; // string

            /** Monto autorizado de la transacción que se requiere anular.
             * Para el caso que se esté anulando una transacción de captura en línea,
             * este monto corresponde al monto de la captura */
            $nullificationInput->authorizedAmount = $authorizedAmount; // decimal

            $nullificationInput->buyOrder = $buyOrder; // string

            if ($commercecode == null){
                $nullificationInput->commerceId = floatval($this->config->getCommerceCode());
            } else {
                $nullificationInput->commerceId = floatval($commercecode);
            }

            $nullificationInput->nullifyAmount = $nullifyAmount;

            $nullifyResponse = $this->_nullify(
                    array("nullificationInput" => $nullificationInput));

            /** 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 */
            if ($validationResult === TRUE) {

                $nullificationOutput = $nullifyResponse->return;
                return $nullificationOutput;
            } else {
                $error["error"] = "Error validando conexión a Webpay";
                $error["error"] = "No se pudo completar la conexió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;
    }
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
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
1308392
def CrearLiqSecundariaBase(self, pto_emision=1, nro_orden=None, 
            nro_contrato=None,
            cuit_comprador=None, nro_ing_bruto_comprador=None,
            cod_puerto=None, des_puerto_localidad=None, 
            cod_grano=None, cantidad_tn=None,
            cuit_vendedor=None, nro_act_vendedor=None,  # nuevo!!
            nro_ing_bruto_vendedor=None,
            actua_corredor=None, liquida_corredor=None, cuit_corredor=None,
            nro_ing_bruto_corredor=None, 
            fecha_precio_operacion=None, precio_ref_tn=None,
            precio_operacion=None, alic_iva_operacion=None, campania_ppal=None,
            cod_localidad_procedencia=None, cod_prov_procedencia=None,
            datos_adicionales=None,
            **kwargs):
        ""
 
        # creo el diccionario con los campos generales de la liquidación:
        self.liquidacion = dict(
            ptoEmision=pto_emision, nroOrden=nro_orden,
            numeroContrato=nro_contrato or None, cuitComprador=cuit_comprador, 
            nroIngBrutoComprador=nro_ing_bruto_comprador,
            codPuerto=cod_puerto, desPuertoLocalidad=des_puerto_localidad,
            codGrano=cod_grano, cantidadTn=cantidad_tn,
            cuitVendedor=cuit_vendedor, nroActVendedor=nro_act_vendedor,
            nroIngBrutoVendedor=nro_ing_bruto_vendedor,
            actuaCorredor=actua_corredor, liquidaCorredor=liquida_corredor,
            cuitCorredor=cuit_corredor or None, 
            nroIngBrutoCorredor=nro_ing_bruto_corredor or None,
            fechaPrecioOperacion=fecha_precio_operacion,
            precioRefTn=precio_ref_tn, precioOperacion=precio_operacion,
            alicIvaOperacion=alic_iva_operacion or None, 
            campaniaPPal=campania_ppal,
            codLocalidad=cod_localidad_procedencia, 
            codProvincia=cod_prov_procedencia,
            datosAdicionales=datos_adicionales,
            )
        # inicializo las listas que contentran las retenciones y deducciones:
        self.deducciones = []
        self.percepciones = []
        self.opcionales = []
        self.factura_papel = None
        return True
903142
def ConsultarLiquidacionesPorContrato(self, nro_contrato=None, 
                                                cuit_comprador=None, 
                                                cuit_vendedor=None,
                                                cuit_corredor=None,
                                                cod_grano=None,
                                                **kwargs):
        ""
        ret = self.client.liquidacionPorContratoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        nroContrato=nro_contrato,
                        cuitComprador=cuit_comprador,
                        cuitVendedor=cuit_vendedor,
                        cuitCorredor=cuit_corredor,
                        codGrano=cod_grano,
                        )
        ret = ret['liqPorContratoCons']
        self.__analizar_errores(ret)
        if 'coeRelacionados' in ret:
            # analizo la respuesta = [{'coe': "...."}]
            self.DatosLiquidacion = sorted(ret['coeRelacionados'])  
            # establezco el primer COE
            self.LeerDatosLiquidacion()
        return True
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