Realiza la consulta remota a ARBA, estableciendo los resultados
766897
def ConsultarContribuyentes(self, fecha_desde, fecha_hasta, cuit_contribuyente):
        ""
        self.limpiar()
        try:

            self.xml = SimpleXMLElement(XML_ENTRADA_BASE)
            self.xml.fechaDesde = fecha_desde
            self.xml.fechaHasta = fecha_hasta
            self.xml.contribuyentes.contribuyente.cuitContribuyente = cuit_contribuyente

            xml = self.xml.as_xml()
            self.CodigoHash = md5.md5(xml).hexdigest()
            nombre = "DFEServicioConsulta_%s.xml" % self.CodigoHash

            # guardo el xml en el archivo a enviar y luego lo re-abro:
            archivo = open(os.path.join(tempfile.gettempdir(), nombre), "w")
            archivo.write(xml)
            archivo.close()
            archivo = open(os.path.join(tempfile.gettempdir(), nombre), "r")

            if not self.testing:
                response = self.client(user=self.Usuario, password=self.Password,
                                   file=archivo)
            else:
                response = open(self.testing).read()
            self.XmlResponse = response
            self.xml = SimpleXMLElement(response)
            if 'tipoError' in self.xml:
                self.TipoError = str(self.xml.tipoError)
                self.CodigoError = str(self.xml.codigoError)
                self.MensajeError = str(self.xml.mensajeError).decode('latin1').encode("ascii", "replace")
            if 'numeroComprobante' in self.xml:
                self.NumeroComprobante = str(self.xml.numeroComprobante)
                self.CantidadContribuyentes = int(self.xml.cantidadContribuyentes)
                if 'contribuyentes' in self.xml:
                    for contrib in self.xml.contribuyente:
                        c = {
                            'CuitContribuytente': str(contrib.cuitContribuyente),
                            'AlicuotaPercepcion': str(contrib.alicuotaPercepcion),
                            'AlicuotaRetencion': str(contrib.alicuotaRetencion),
                            'GrupoPercepcion': str(contrib.grupoPercepcion),
                            'GrupoRetencion': str(contrib.grupoRetencion),
                            'Errores': [],
                            }
                        self.contribuyentes.append(c)
                    # establecer valores del primer contrib (sin eliminarlo)
                    self.LeerContribuyente(pop=False)
            return True
        except Exception, e:
                ex = traceback.format_exception( sys.exc_type, sys.exc_value, sys.exc_traceback)
                self.Traceback = ''.join(ex)
                try:
                    self.Excepcion = traceback.format_exception_only( sys.exc_type, sys.exc_value)[0]
                except:
                    self.Excepcion = u"<no disponible>"
                return False
1353652
public function agregarRuta($metodo, $ruta, $accion, array $parametros = null, $estado_http = 200)
    {
        // Normalizamos el uri de la ruta argumentada
        $ruta = $this->normalizarUri($ruta);

        // Limpiamos y dividimos la ruta en partes
        $partes = explode('/', trim($ruta, '/ '));

        // Contamos las partes resultantes
        $conteo_partes = count($partes);

        // Declaramos la rama base como actual
        $rama_actual = &$this->arbol_rutas;

        // Preparamos variable que clasifica la ruta como simple
        $es_simple = true;

        // Verificamos si hay suficientes partes para recorrerlas
        if (!($conteo_partes === 1 && $partes[0] === '')) {

            // Recorremos las partes para actualizar la rama actual
            for ($i = 0; $i < $conteo_partes; $i++) {

                if (substr($partes[$i], 0, 1) == ':') {
                    $es_simple = false;
                    if (!isset($rama_actual['ramas']['*'])) {
                        $rama_actual['ramas']['*'] = ['ramas' => [], 'nombre' => substr($partes[$i], 1)];
                    }

                    $rama_actual = &$rama_actual['ramas']['*'];
                } else {
                    if (!isset($rama_actual['ramas'][$partes[$i]])) {
                        $rama_actual['ramas'][$partes[$i]] = ['ramas' => []];
                    }

                    $rama_actual = &$rama_actual['ramas'][$partes[$i]];
                }
            }

        }

        // Preparamos el metodo argumentado
        $metodo = (array)$metodo;

        // Insertamos la ruta a la rama actual
        $rama_actual['ruta'] = $ruta;

        // Preparamos las acciones de la rama actual
        if (!isset($rama_actual['x'])) {
            $rama_actual['x'] = [];
        }

        // Recorremos los metodos para agregar las respectivas acciones
        foreach ($metodo as $m) {
            // Agregamos ruta simple en caso necesario
            if ($es_simple) {
                $this->rutas_simples[$ruta][strtoupper($m)]['accion'] = $accion;
                $this->rutas_simples[$ruta][strtoupper($m)]['estado_http'] = $estado_http;
                if (isset($parametros)) {
                    $this->rutas_simples[$ruta][strtoupper($m)]['parametros'] = $parametros;
                }
            } else {
                $rama_actual['x'][strtoupper($m)]['accion'] = $accion;
                $rama_actual['x'][strtoupper($m)]['estado_http'] = $estado_http;
                if (isset($parametros)) {
                    $rama_actual['x'][strtoupper($m)]['parametros'] = $parametros;
                }
            }
        }

        // Liberamos memoria
        unset($rama_actual);
    }
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]
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]
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
989016
def AgregarDatosAutorizacion(self, nro_remito=None, cod_autorizacion=None, fecha_emision=None, fecha_vencimiento=None, **kwargs):
        ""
        self.remito['datosEmision'] = dict(nroRemito=nro_remito, codAutorizacion=cod_autorizacion,
                                                fechaEmision=fecha_emision, fechaVencimiento=fecha_vencimiento,
                                               )
        return True
1266983
def GenerarAjusteFisico(self):
        ""
        
        # renombrar la clave principal de la estructura
        if 'liquidacion' in self.solicitud:
            liq = self.solicitud.pop('liquidacion')
            self.solicitud = liq
        
        # llamar al webservice:
        ret = self.client.generarAjusteFisico(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        solicitud=self.solicitud,
                        )
        # analizar el resultado:
        ret = ret['respuesta']
        self.__analizar_errores(ret)
        liqs = ret.get('liquidacion', [])
        liq = liqs[0] if liqs else None
        self.AnalizarLiquidacion(liq)
        return True
665256
def ConsultarTiposEstado(self, sep="||"):
        ""
        ret = self.client.consultarTiposEstado(
                            authRequest={
                                'token': self.Token, 'sign': self.Sign,
                                'cuitRepresentada': self.Cuit, },
                                )['consultarTiposEstadoReturn']
        self.__analizar_errores(ret)
        array = ret.get('arrayTiposEstado', [])
        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]
344928
def ConsultarCTG(self, numero_carta_de_porte=None, numero_ctg=None, 
                     patente=None, cuit_solicitante=None, cuit_destino=None,
                     fecha_emision_desde=None, fecha_emision_hasta=None):
        ""
        ret = self.client.consultarCTG(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        consultarCTGDatos=dict(
                            cartaPorte=numero_carta_de_porte, 
                            ctg=numero_ctg,
                            patente=patente,
                            cuitSolicitante=cuit_solicitante,
                            cuitDestino=cuit_destino,
                            fechaEmisionDesde=fecha_emision_desde,
                            fechaEmisionHasta=fecha_emision_hasta,
                            )))['response']
        self.__analizar_errores(ret)
        datos = ret.get('arrayDatosConsultarCTG')
        if datos:
            self.DatosCTG = datos
            self.LeerDatosCTG(pop=False)
            return True
        else:
            self.DatosCTG = []
        return ''
832665
def ConsultarRetencionesTabacaleras(self, sep="||"):
        ""
        ret = self.client.consultarRetencionesTabacaleras(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('retencion', [])
        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]
1133553
def AgregarTributo(self, cod_tributo, descripcion=None,     
                       base_imponible=None, alicuota=None, importe=None):
        ""
        trib = {'codTributo': cod_tributo, 'descripcion': descripcion, 
                'baseImponible': base_imponible, 'alicuota': alicuota, 
                'importe': importe}
        if 'ajusteFinanciero' in self.solicitud:
            self.solicitud['ajusteFinanciero']['tributo'].append(trib)
        else:
            self.solicitud['tributo'].append(trib)
        return True
1202621
def consultar_status_operacional(self):
        
        resp = self._http_post('consultarstatusoperacional')
        conteudo = resp.json()
        return RespostaConsultarStatusOperacional.analisar(
                conteudo.get('retorno'))
317267
public function submit()
    {
        $uri   = isset($_GET["uri"]) ? $_GET["uri"] : "/"; //recupera la url del proyecto
        $paths = explode("/", $uri); // divide la url en partes y forma un array
        // hacer consdicional para saber si esta en un
        //controllador o en la ruta principal
        if ($uri == "/") {
            //principal
            $res = array_key_exists("/", $this->_controladores); // buscando si existe la ruta (/) en el array de _controladores
            if ($res != "" && $res == 1) {
                // comprobando
                foreach ($this->_controladores as $ruta => $controller) {
                    // recorriendo los _controladores
                    if ($ruta == "/") { // comprobamos si las rutas con iguales
                        $controlador = $controller; // asignamos a una variable el controlador
                    }
                }
                $this->getController("index", $controlador); // llamamos al metodo que nos recupera el controlador
            }
        } else {
            //controladores y metodos
            echo "<b>Url:</b> ".$uri."<br><hr>";
            $estado = false;
            foreach ($this->_controladores as $ruta => $cont) {
                //echo "<br><b>Ruta:</b> ".$ruta."<br>";
                if (trim($ruta, "/") != "") {
                    $pos = strpos($uri, trim($ruta, "/"));

                    if ($pos === false) {
                        //echo "<small style='color:red;'>no se encontro</small><br>";
                    } else {
                        //echo "<small style='color:green;'>se econtro </small><br>";
                        $arrayParams  = array(); //array donde se guardaran los parametros de la web
                        $estado       = true; // estado de ruta
                        $controlador  = $cont;
                        $metodo       = "";
                        $cantidadRuta = count(explode("/", trim($ruta, "/")));
                        $cantidad     = count($paths);
                        if ($cantidad > $cantidadRuta) {
                            $metodo = $paths[$cantidadRuta];
                            for ($i = 0; $i < count($paths); $i++) {
                                if ($i > $cantidadRuta) {
                                    $arrayParams[] = $paths[$i];
                                }
                            }
                        }
                        //echo "<b>Parametros: </b>".json_encode($arrayParams);
                        //echo "<br><b>cantidad Rutas</b>: ".count(explode("/",trim($ruta,"/")))."<br>";
                        //echo "<br><b>cantidad Uris</b>: ".count($paths)."<br>";
                        /*if(count($paths) > 1){
                        $metodo = $paths[1];
                        }*/
                        $this->getController($metodo, $controlador, $arrayParams);

                    }
                }
                //echo "<hr>";
            }

            if ($estado == false) {
                die("error en la ruta");
            }

        }
    }
68274
def AgregarAjusteMonetario(self, precio_unitario, precio_recupero=None, 
                               **kwargs):
        ""
        d = {'precioUnitario': precio_unitario, 
             'precioRecupero': precio_recupero,
            }
        item_liq = self.solicitud['itemDetalleAjusteLiquidacion'][-1]
        item_liq['ajusteMonetario'] = d
        return True
647632
def ConsultarTiposOperacion(self, sep="||"):
        ""
        ops = []
        ret = self.client.tipoActividadConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
        self.__analizar_errores(ret)
        for it_act in ret.get('tiposActividad', []):

            ret = self.client.tipoOperacionXActividadConsultar(
                            auth={
                                'token': self.Token, 'sign': self.Sign,
                                'cuit': self.Cuit, },
                            nroActLiquida=it_act['codigoDescripcion']['codigo'],
                            )['tipoOperacionReturn']
            self.__analizar_errores(ret)
            array = ret.get('tiposOperacion', [])
            if sep:
                ops.extend([("%s %%s %s %%s %s %%s %s" % (sep, sep, sep, sep)) % 
                    (it_act['codigoDescripcion']['codigo'],
                     it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
                   for it in array])
            else:
                ops.extend([(it_act['codigoDescripcion']['codigo'],
                             it['codigoDescripcion']['codigo'], 
                             it['codigoDescripcion']['descripcion']) 
                           for it in array])
        return ops
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
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]