Consulta el último No de orden registrado para CG
347442
def ConsultarCertificacionUltNroOrden(self, pto_emision=1):
        ""
        ret = self.client.cgConsultarUltimoNroOrden(
                    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
105499
def cancelar_ultima_venda(self, chave_cfe, dados_cancelamento):
        
        retorno = super(ClienteSATLocal, self).\
                cancelar_ultima_venda(chave_cfe, dados_cancelamento)
        return RespostaCancelarUltimaVenda.analisar(retorno)
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
1248280
def ConsultarMotivos(self, sep="||"):
        ""
        ret = self.client.consultarMotivos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('motivo', [])
        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]
1252671
def ConsultarConstanciaCTGPDF(self, numero_ctg=None, 
                                        archivo="constancia.pdf"):
        ""
        ret = self.client.consultarConstanciaCTGPDF(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        ctg=numero_ctg, 
                        ))['response']
        self.__analizar_errores(ret)
        datos = base64.b64decode(ret.get('archivo', ""))
        f = open(archivo, "wb")
        f.write(datos)
        f.close()
        return True
1177701
def ConsultarOperaciones(self, sep="||"):
        ""
        ret = self.client.consultarOperaciones(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('operacion', []) + ret.get('operacionPorcina', []) 
        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]
958572
def CancelarAnticipo(self, pto_emision=None, nro_orden=None, coe=None, 
                               pdf=None):
        ""
        
        # llamo al webservice:
        ret = self.client.lpgCancelarAnticipo(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        ptoEmision=pto_emision,
                        nroOrden=nro_orden,
                        pdf="S" if pdf else "N",
                        )

        # analizo la respusta
        ret = ret['liqConsReturn']
        self.__analizar_errores(ret)
        if 'liquidacion' in ret:
            aut = ret['autorizacion']
            liq = ret['liquidacion']
            self.AnalizarLiquidacion(aut, liq)
        # 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
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;
    }
1190504
function capture($authorizationCode, $captureAmount, $buyOrder) {

        try {

            $CaptureInput = new CaptureInput();

            /** Código de autorización de la transacción que se requiere capturar */
            $CaptureInput->authorizationCode = $authorizationCode; // string

            /** Orden de compra de la transacción que se requiere capturar */
            $CaptureInput->buyOrder = $buyOrder; // string

            /** Monto que se desea capturar */
            $CaptureInput->captureAmount = $captureAmount; // decimal

            /** Código de comercio o tienda mall que realizó la transacción */
            $CaptureInput->commerceId = floatval($this->config->getCommerceCode());

            $captureResponse = $this->_capture(
                array("captureInput" => $CaptureInput)
            );

            /** 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) {

                $wsCaptureOutput = $captureResponse->return;
                return $wsCaptureOutput;

            } 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;
    }
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
320183
def AnularCertificacion(self, coe):
        ""
        ret = self.client.cgSolicitarAnulacion(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        )
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        self.Estado = ret.get('estadoCertificado', "")
        return self.COE
377264
def ConsultarTipoCertificadoDeposito(self, sep="||"):
        ""
        ret = self.client.tipoCertificadoDepositoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoCertDepReturn']
        self.__analizar_errores(ret)
        array = ret.get('tiposCertDep', [])
        return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
615330
def ConfirmarArribo(self, numero_carta_de_porte, numero_ctg, 
                        cuit_transportista, peso_neto_carga, 
                        consumo_propio, establecimiento=None, cuit_chofer=None,
                        **kwargs):
        ""
        ret = self.client.confirmarArribo(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        datosConfirmarArribo=dict(
                            cartaPorte=numero_carta_de_porte, 
                            ctg=numero_ctg,
                            cuitTransportista=cuit_transportista,
                            cuitChofer=cuit_chofer,
                            cantKilosCartaPorte=peso_neto_carga,
                            consumoPropio=consumo_propio,
                            establecimiento=establecimiento,
                            )))['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['codigoOperacion'])
            self.Observaciones = ""
        return self.CodigoTransaccion
1097901
def ConsultarTiposLiquidacion(self, sep="||"):
        ""
        ret = self.client.consultarTiposLiquidacion(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('tipoLiquidacion', [])
        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]
215182
function getAsistenciaComisiones (senador, periodo, incluyeSenador) {
  assert.equal(typeof senador, 'object', '[senadores-asistencia]: El senador general ingresada debe ser un objeto.')
  assert.equal(typeof periodo, 'number', '[senadores-asistencia]: El periodo general ingresada debe ser un número.')
  assert.ok(typeof incluyeSenador === 'boolean' || typeof incluyeSenador === 'undefined', '[senadores-asistencia]: La opción \'incluye senador\' debe ser de tipo booleana.')

  let url = URL_ASISTENCIA_COMISIONES.replace(/:periodo:/, periodo)
  url = url.replace(/:senador-id:/, senador.id)

  return scraperjs.StaticScraper.create()
    .get(url)
    .scrape($ => {
      const oficiales = $('table').first().find('tr:not(:first-child)').map(function () {
        const nombreOficial = $(this).find('td:nth-child(1)').text().trim()
        const total = parseInt($(this).find('td:nth-child(2)').text().trim())
        const asiste = parseInt($(this).find('td:nth-child(3)').text().trim())
        return {
          nombre: nombreOficial,
          total,
          asiste
        }
      }).get()
      const otras = $('table').last().find('tr:not(:first-child)').map(function () {
        const nombreOtra = $(this).find('td:nth-child(1)').text().trim()
        const reemplazante = parseInt($(this).find('td:nth-child(2)').text().trim())
        const asistente = parseInt($(this).find('td:nth-child(3)').text().trim())
        return {
          nombre: nombreOtra,
          reemplazante,
          asistente
        }
      }).get()
      if (incluyeSenador) {
        return {
          senador,
          periodo,
          oficiales,
          otras
        }
      }
      return {
        periodo,
        oficiales,
        otras
      }
    })
}
867590
def ConsultarProvincias(self, sep="||"):
        ""
        ret = self.client.provinciasConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['provinciasReturn']
        self.__analizar_errores(ret)
        array = ret.get('provincias', [])
        if sep is None:
            return dict([(int(it['codigoDescripcion']['codigo']), 
                              it['codigoDescripcion']['descripcion']) 
                         for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
703208
def ConsultarLiquidacionSecundariaUltNroOrden(self, pto_emision=1):
        ""
        ret = self.client.lsgConsultarUltimoNroOrden(
                    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