Método interno para analizar la respuesta de AFIP (ajustes)
969124
def AnalizarAjuste(self, aut, base=True):
        ""

        self.__ajuste_base = None
        self.__ajuste_debito = None
        self.__ajuste_credito = None
        
        # para compatibilidad con la generacion de PDF (completo datos)
        if hasattr(self, "liquidacion") and self.liquidacion and base:
            self.AnalizarLiquidacion(aut=None, liq=self.liquidacion)
            
        self.params_out['errores'] = self.errores
            
        # proceso la respuesta de autorizar, ajustar (y consultar):
        if aut:
            # en caso de anulación o no ser ajuste, ahora no devuelve datos:
            self.COE = str(aut.get('coe', ""))
            self.COEAjustado = aut.get('coeAjustado')
            self.NroContrato = aut.get('nroContrato')
            self.Estado = aut.get('estado', "")

            totunif = aut.get("totalesUnificados") or {}
            self.Subtotal = totunif.get('subTotalGeneral')
            self.TotalIva105 = totunif.get('iva105')
            self.TotalIva21 = totunif.get('iva21')
            self.TotalRetencionesGanancias = totunif.get('retencionesGanancias')
            self.TotalRetencionesIVA = totunif.get('retencionesIVA')
            self.TotalOtrasRetenciones = totunif.get('importeOtrasRetenciones')
            self.TotalNetoAPagar = totunif.get('importeNeto')
            self.TotalIvaRg4310_18 = totunif.get('ivaRG4310_18')
            self.TotalPagoSegunCondicion = totunif.get('pagoSCondicion')
            
            # actualizo parámetros de salida:
            self.params_out['coe'] = self.COE
            self.params_out['coe_ajustado'] = self.COEAjustado
            self.params_out['estado'] = self.Estado
            self.params_out['nro_orden'] = aut.get('nroOrden')
            self.params_out['cod_tipo_operacion'] = aut.get('codTipoOperacion')
            self.params_out['nro_contrato'] = aut.get('nroContrato')
            self.params_out['nro_op_comercial'] = aut.get('nroOpComercial', "")

            
            # actualizo totales solo para ajuste base (liquidacion general) 
            if base:
                self.params_out['subtotal'] = self.Subtotal
                self.params_out['iva_deducciones'] = totunif.get('ivaDeducciones')
                self.params_out['subtotal_deb_cred'] = totunif.get('subTotalDebCred')
                self.params_out['total_base_deducciones'] = totunif.get('totalBaseDeducciones')
                self.params_out['total_iva_10_5'] = self.TotalIva105
                self.params_out['total_iva_21'] = self.TotalIva21
                self.params_out['total_retenciones_ganancias'] = self.TotalRetencionesGanancias
                self.params_out['total_retenciones_iva'] = self.TotalRetencionesIVA
                self.params_out['total_otras_retenciones'] = self.TotalOtrasRetenciones
                self.params_out['total_neto_a_pagar'] = self.TotalNetoAPagar
                self.params_out['total_iva_rg_4310_18'] = self.TotalIvaRg4310_18
                self.params_out['total_pago_segun_condicion'] = self.TotalPagoSegunCondicion
            
                # almaceno los datos de ajustes crédito y débito para usarlos luego
                self.__ajuste_base = aut
                self.__ajuste_debito = aut.get('ajusteDebito') or {}
                self.__ajuste_credito = aut.get('ajusteCredito') or {}
        return True
779932
def AutorizarRemito(self, archivo="qr.png"):
        ""
        response = self.client.autorizarRemito(
                                authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit},
                                codRemito=self.remito['codRemito'],
                                estado=self.remito['estado'])
        ret = response.get("autorizarRemitoReturn")
        if ret:
            self.__analizar_errores(ret)
            self.__analizar_observaciones(ret)
            self.__analizar_evento(ret)
            self.AnalizarRemito(ret, archivo)
        return bool(self.CodRemito)
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]
881686
def ConsultarDepositosAcopio(self, sep="||"):
        ""
        ret = self.client.consultarDepositosAcopio(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('acopio', [])
        if sep is None:
            return array
        else:
            return [("%s %%s %s %%s %s %%s %s %%s %s" % (sep, sep, sep, sep, sep)) %
                    (it['codigo'], it['direccion'], it['localidad'], it['codigoPostal']) 
                    for it in array]
318580
def AjustarLiquidacionUnificadoPapel(self):
        ""
        
        # limpiar arrays no enviados:
        if not self.ajuste['ajusteBase']['certificados']:
            del self.ajuste['ajusteBase']['certificados']
        for k1 in ('ajusteCredito', 'ajusteDebito'):
            for k2 in ('retenciones', 'deducciones'):
                if not self.ajuste[k1][k2]:
                    del self.ajuste[k1][k2]
        ret = self.client.liquidacionAjustarUnificadoPapel(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        **self.ajuste
                        )
        ret = ret['ajustePapelReturn']
        self.__analizar_errores(ret)
        if 'ajustePapel' in ret:
            aut = ret['ajustePapel']
            self.AnalizarAjuste(aut)
        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]
1325051
def ConsultarTiposCategoriaReceptor(self, sep="||"):
        ""
        ret = self.client.consultarTiposCategoriaReceptor(
                            authRequest={
                                'token': self.Token, 'sign': self.Sign,
                                'cuitRepresentada': self.Cuit, },
                                )['consultarCategoriasReceptorReturn']
        self.__analizar_errores(ret)
        array = ret.get('arrayCategoriasReceptor', [])
        lista = [it['codigoDescripcionString'] for it in array]
        return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista]
1292038
def _dataset_qa(self, dataset):
        """"""

        # 1. VALIDACIONES
        # chequea que haya por lo menos algún formato de datos reconocido
        has_data_format = helpers.dataset_has_data_distributions(dataset)

        # chequea que algunos campos tengan longitudes mínimas
        has_title = "title" in dataset
        has_description = "description" in dataset
        if has_title:
            has_min_title = len(dataset["title"]) >= MIN_DATASET_TITLE
        else:
            has_min_title = False
        if has_description:
            has_min_desc = len(
                dataset["description"]) >= MIN_DATASET_DESCRIPTION
        else:
            has_min_desc = False

        # 2. EVALUACION DE COSECHA: evalua si se cosecha o no el dataset
        harvest = (has_title and has_description and
                   has_data_format and has_min_title and has_min_desc)

        # 3. NOTAS: genera notas de validación
        notes = []
        if not has_data_format:
            notes.append("No tiene distribuciones con datos.")
        if not has_title:
            notes.append("Dataset sin titulo {}".format(dataset))
        else:
            if not has_min_title:
                notes.append("Titulo tiene menos de {} caracteres".format(
                    MIN_DATASET_TITLE))
        if not has_description:
            notes.append("Dataset sin descripcion {}".format(dataset))
        else:
            if not has_min_desc:
                notes.append("Descripcion tiene menos de {} caracteres".format(
                    MIN_DATASET_DESCRIPTION))

        return harvest, notes
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
535984
def ConsultarCondicionesVenta(self, sep="||"):
        ""
        ret = self.client.consultarCondicionesVenta(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('condicionVenta', [])
        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]
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]
780113
def AnalizarRemito(self, ret, archivo=None):
        ""
        if ret:
            self.CodRemito = ret.get("codRemito")
            self.TipoComprobante = ret.get("tipoComprobante")
            self.PuntoEmision = ret.get("puntoEmision")
            datos_aut = ret.get('datosAutorizacion')
            if datos_aut:
                self.NroRemito = datos_aut.get('nroRemito')
                self.CodAutorizacion = datos_aut.get('codAutorizacion')
                self.FechaEmision = datos_aut.get('fechaEmision')
                self.FechaVencimiento = datos_aut.get('fechaVencimiento')
            self.Estado = ret.get('estado')
            self.Resultado = ret.get('resultado')
            self.QR = ret.get('qr') or ""
            if archivo:
                qr = base64.b64decode(self.QR)
                f = open(archivo, "wb")
                f.write(qr)
                f.close()
47456
def ConsultarTipoActividadRepresentado(self, sep="||"):
        ""
        try:
            ret = self.client.tipoActividadRepresentadoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
            self.__analizar_errores(ret)
            array = ret.get('tiposActividad', [])
            self.Excepcion = self.Traceback = ""
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
        except Exception:
            ex = utils.exception_info()
            self.Excepcion = ex['msg']
            self.Traceback = ex['tb']
            if sep:
                return ["ERROR"]
739149
def ConsultarPuntosVentas(self, sep="||"):
        ""
        ret = self.client.consultarPuntosVenta(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('puntoVenta', [])
        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]
284556
def AnalizarLiquidacion(self, liq):
        ""
        # proceso los datos básicos de la liquidación (devuelto por consultar):
        if liq:
            cab = liq['encabezado']
            self.CAE = str(cab['cae'])
            self.FechaComprobante = str(cab['fechaComprobante'])
            self.NroComprobante = cab['nroComprobante']
            tot = liq['resumenTotales']
            self.AlicuotaIVA = tot['alicuotaIVA']
            self.TotalNeto = tot['totalNetoLiquidacion']
            self.ImporteIVA = tot['importeIVA']
            self.TotalBonificacionesCalidad = tot['totalBonificacionesCalidad']
            self.TotalPenalizacionesCalidad = tot['totalPenalizacionesCalidad']
            self.TotalBonificacionesComerciales = tot['totalBonificacionesComerciales']
            self.TotalDebitosComerciales = tot['totalDebitosComerciales']
            self.TotalOtrosImpuestos = tot['totalOtrosImpuestos']
            self.Total = tot['totalLiquidacion']

            # parámetros de salida:
            self.params_out = dict(
                tipo_cbte=liq['encabezado']['tipoComprobante'],
                pto_vta=liq['encabezado']['puntoVenta'],
                nro_cbte=liq['encabezado']['nroComprobante'],
                fecha=str(liq['encabezado']['fechaComprobante']),
                cae=str(liq['encabezado']['cae']),
                domicilio_comprador=liq['encabezado']['domicilioComprador'],
                tambero=dict(
                    cuit=liq['tambero']['cuit'],
                    iibb=liq['tambero']['iibb'],
                    razon_social=liq['tambero']['razonSocial'],
                    situacion_iva=liq['tambero']['situacionIVA'],
                    domicilio_fiscal=liq['tambero']['domicilioFiscal'],
                    provincia=liq['tambero']['provincia'],
                    cod_postal=liq['tambero']['codPostal'],
                    ),
                resumen_kg_remitidos=liq['resumenKgRemitidos'],
                alicuota_iva=liq['resumenTotales']['alicuotaIVA'],
                importe_iva=liq['resumenTotales']['importeIVA'],
                total_neto=liq['resumenTotales']['totalNetoLiquidacion'],
                total_bonificaciones_calidad=liq['resumenTotales']['totalBonificacionesCalidad'],
                total_penalizaciones_calidad=liq['resumenTotales']['totalPenalizacionesCalidad'],
                total_bonificaciones_comerciales=liq['resumenTotales']['totalBonificacionesComerciales'],
                total_debitos_comerciales=liq['resumenTotales']['totalDebitosComerciales'],
                total_otros_impuestos=liq['resumenTotales']['totalOtrosImpuestos'],
                total=liq['resumenTotales']['totalLiquidacion'],
                bonificacion_penalizacion=[],
                remitos=[],
                otro_impuesto=[],               
                pdf=liq.get('pdf'),
                )
            for ret in liq.get('bonificacionPenalizacion', []):
                self.params_out['bonificacion_penalizacion'].append(dict(
                    retencion_codigo=ret['codigo'],
                    retencion_importe=ret['importe'],
                    ))
            for trib in liq.get('otroImpuesto',[]):
                self.params_out['otro_impuesto'].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
837027
def ConsultarCodigoGradoReferencia(self, sep="||"):
        ""
        ret = self.client.codigoGradoReferenciaConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['gradoRefReturn']
        self.__analizar_errores(ret)
        array = ret.get('gradosRef', [])
        if sep is None:
            return dict([(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]
32388
private function analysis():\ArrayIterator
    {
        $apps = $this->getApplist();
        $routing = new \ArrayIterator();
        foreach ($apps as $one => $values) {
            $mercure = new Routing($values->name, (isset($values->prefix)? $values->prefix : ""), $this->is_base);
            $mercure->routingRegister();
            $appmercure = $mercure->routes();
            $apppublic = array();
            foreach ($appmercure as $mercure => $valk) {
                if ($valk['visibility'] == "public") {
                    array_push($apppublic, array("name" => $valk['routename'],
                        "path" => $valk['path'], "params" => $valk['params']?? ""));
                }
            }
            $routing->append(array($values->name => $apppublic));
        }
        return ($routing);
    }