Descarga el archivo de AFIP, devuelve 200 o 304 si no fue modificado
329044
def Descargar(self, url=URL, filename="padron.txt", proxy=None):
        ""
        proxies = {}
        if proxy:
            proxies['http'] = proxy
            proxies['https'] = proxy
            proxy_handler = urllib2.ProxyHandler(proxies)
        print "Abriendo URL %s ..." % url
        req = urllib2.Request(url)
        if os.path.exists(filename):
            http_date = formatdate(timeval=os.path.getmtime(filename), 
                                   localtime=False, usegmt=True)  
            req.add_header('If-Modified-Since', http_date)
        try:
            web = urllib2.urlopen(req)
        except urllib2.HTTPError, e:
            if e.code == 304:
                print "No modificado desde", http_date
                return 304
            else:
                raise
        # leer info del request:
        meta = web.info()
        lenght = float(meta['Content-Length'])
        date = meta['Last-Modified']
        tmp = open(filename + ".zip", "wb")
        print "Guardando"
        size = 0
        p0 = None
        while True:
            p = int(size / lenght * 100)
            if p0 is None or p>p0:
                print "Leyendo ... %0d %%" % p
                p0 = p
            data = web.read(1024*100)
            size = size + len(data)
            if not data:
                print "Descarga Terminada!"
                break
            tmp.write(data)
        print "Abriendo ZIP..."
        tmp.close()
        web.close()
        uf = open(filename + ".zip", "rb")
        zf = zipfile.ZipFile(uf)
        for fn in zf.namelist():
            print "descomprimiendo", fn
            tf = open(filename, "wb")
            tf.write(zf.read(fn))
            tf.close()
        return 200
48094
private function init(){
        //Load Archivos de Funciones
        $this->loadFunctionsFiles();
        //Instancio el sistema de Cache
        $this->cache= new Support\Cache\Cache();
        //EnolaContext->init(): Cargo las configuraciones de contexto faltante
        $this->context->init();
        //Instancio el motor de Dependencias
        $this->dependenciesEngine= new Support\DependencyEngine\DependenciesEngine();
        //Cargo las librerias definidas por el usuario
        $this->loadLibraries();
    }
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
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
862668
private function _writeExternsheetBiff8()
	{
		$total_references = count($this->_parser->_references);
		$record   = 0x0017;                     // Record identifier
		$length   = 2 + 6 * $total_references;  // Number of bytes to follow

		$supbook_index = 0;           // FIXME: only using internal SUPBOOK record
		$header           = pack("vv",  $record, $length);
		$data             = pack('v', $total_references);
		for ($i = 0; $i < $total_references; ++$i) {
			$data .= $this->_parser->_references[$i];
		}
		return $this->writeData($header . $data);
	}
1282117
function(input) {

			var temp;

			// Si no hay parámetros

			if (!arguments.length) {

				// Construimos la URL con los atributos y la devolvemos como cadena de texto

				return Public.build(this._attributes, this.location);

			// Si el parámetro es `null`

			} else if (input === null) {

				// Vaciamos los atributos

				this._attributes = {};

			// Si el parámetro es una cadena de texto o un objecto

			} else if ((temp = typeof input) === 'string' || (input && temp === 'object')) {

				// Desmontamos la URL y guardamos su información en forma de objeto

				this._attributes = Public.unbuild(input, this.location);

			}

			return this;

		}
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
1347604
public function request(){        
        //Cargo el modulo correspondiente en base al tipo de requerimiento
        if(ENOLA_MODE == 'HTTP'){
            //Cargo el modulo Http
            $this->loadHttpModule();
        }else{
            //Cargo el modulo Cron
            $this->loadCronModule();
        }        
        //Luego de la carga de todos los modulos creo una instancia de Support\View
        $this->view= new Support\View();
        //Cargo la configuracion del usuario
        $this->loadUserConfig();
        //Analizo si estoy en modo HTTP o CLI
        if(ENOLA_MODE == 'HTTP'){
            //Ejecuto el controlador correspondiente
            $this->httpCore->executeHttpRequest();
        }else{
            //Ejecuta el cron controller
            $this->cronCore->executeCronController();
        }        
    }
766242
def escribir(dic, formato, contraer_fechas=False):
    ""
    linea = " " * sum([fmt[1] for fmt in formato])
    comienzo = 1
    for fmt in formato:
        clave, longitud, tipo = fmt[0:3]
        try:
            dec = (len(fmt)>3 and isinstance(fmt[3], int)) and fmt[3] or 2
            if clave.capitalize() in dic:
                clave = clave.capitalize()
            s = dic.get(clave,"")
            if isinstance(s, unicode):
                s = s.encode("latin1")
            if s is None:
                valor = ""
            else:
                valor = str(s)
            # reemplazo saltos de linea por tabulaci{on vertical
            valor = valor.replace("\n\r", "\v").replace("\n", "\v").replace("\r", "\v")
            if tipo == N and valor and valor!="NULL":
                valor = ("%%0%dd" % longitud) % long(valor)
            elif tipo == I and valor:
                valor = ("%%0%d.%df" % (longitud+1, dec) % float(valor)).replace(".", "")
            elif contraer_fechas and clave.lower().startswith("fec") and longitud <= 8 and valor:
                valor = valor.replace("-", "")
            else:
                valor = ("%%-0%ds" % longitud) % valor
            linea = linea[:comienzo-1] + valor + linea[comienzo-1+longitud:]
            comienzo += longitud
        except Exception, e:
            warnings.warn("Error al escribir campo %s pos %s val '%s': %s" % (
                clave, comienzo, valor, str(e)))
    return linea + "\n"
285599
def CrearPlantillaPDF(self, papel="A4", orientacion="portrait"):
        ""
        
        # genero el renderizador con propiedades del PDF
        t = Template(
                 format=papel, orientation=orientacion,
                 title="F 1116 B/C %s" % (self.NroOrden),
                 author="CUIT %s" % self.Cuit,
                 subject="COE %s" % self.params_out.get('coe'),
                 keywords="AFIP Liquidacion Electronica Primaria de Granos", 
                 creator='wslpg.py %s (http://www.PyAfipWs.com.ar)' % __version__,)
        self.template = t
        return True
487593
public function index() {

		$this->Printer->recursive = 0;
		$impresoras = $this->Paginator->paginate();

		$impresorasModificadas = array();
		foreach( $impresoras as $imp ) {
			// por cada impresora, le agrego la cantidad de productos relacionados que tiene
			$printerId = $imp['Printer']['id'];
			$cant = $this->Printer->cantidadDeProductosEnImpresora($printerId);
			$imp['Printer']['cantidad_productos'] = $cant;
			$impresorasModificadas[] = $imp;
		}

		$this->set('printers', $impresorasModificadas);
	}
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
440288
public function writeInOutput()
  {
    $image = $this->applyFilters();

    if ($this->extension == self::IMAGE_TYPE_JPG) {
      header('Content-Type: image/jpg');
      imagejpeg($image, null, $this->jpgQuality);
    } else if ($this->extension == self::IMAGE_TYPE_PNG) {
      header('Content-Type: image/png');
      imagepng($image, null, $this->pngCompression);
    } else {
      throw new \Exception('Impossible de générer l\'image : extension non supportée');
    }
  }
874827
def AutorizarCertificacion(self):
        ""
        
        # limpio los elementos que no correspondan por estar vacios:
        for k1 in ('primaria', 'retiroTransferencia'):
            dic = self.certificacion.get(k1)
            if not dic: continue
            for k2 in ('ctg', 'detalleMuestraAnalisis', 'certificadoDeposito'):
                if k2 in dic and not dic[k2]:
                    del dic[k2]
            
        # llamo al webservice:
        ret = self.client.cgAutorizar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        **self.certificacion
                        )

        # analizo la respusta
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        self.AnalizarAutorizarCertificadoResp(ret)
        return True
37617
protected function writeDataInIO($fp)
  {
    // Écriture des données
    if ($this->useAssociativeArray) {
      foreach ($this->data as $donnee) {
        foreach ($donnee as &$champ) {
          $champ = (is_string($champ)) ? iconv("UTF-8", "Windows-1252//TRANSLIT", $champ) : $champ;
        }
        $this->fputcsv($fp, $donnee, ';', $this->enclosures);
      }
    } else {
      for ($i = 0; $i < count($this->data); $i++) {
        for ($j = 0; $j < count($this->data[$i]); $j++) {
          $this->fputcsv($fp, $this->data[$i][$j], ';', $this->enclosures);
        }
      }
    }
  }
419712
protected function loadFunctionsFiles(){           
        //Carga del modulo errores - se definen manejadores de errores
        require $this->context->getPathFra() . 'Support/fn_error.php';    
        //Carga de modulo para carga de archivos
        require $this->context->getPathFra() . 'Support/fn_load_files.php';      
        //Carga el modulo de funciones de vista exportadas al usuario de manera simple
        require $this->context->getPathFra() . 'Support/fn_view.php';
    }
967801
public function archive($fileB64, $fileName, $subject, $date2, $type, $author, $comment, $ref, $amount, $tagsLst)
    {
        $this->client = $this->setClientSoap($this->URL_WSDL_ARCHIVE);

        // Construction du tableau des paramètres
        $fileParam = array('content' => $fileB64,
                            'fileName' => $fileName,
                            'subject' => $subject,
                            'date1' => date(DATE_RFC2822),
                            'date2' => $date2,
                            'type' => $type,
                            'author' => $author,
                            'comment' => $comment,
                            'ref' => $ref,
                            'amount' => $amount,
                            'generic1' => 'gen1',
                            'generic2' => 'gen2',
                            'tag' => $tagsLst, );

        $params = array(
                'file' => $fileParam,
            );

        $result = $this->client->call('archive', $params, self::API_NAMESPACE, self::API_NAMESPACE, $this->createHeaders());

        if ($this->client->fault) {
            $this->errors[] = $this->client->faultstring;

            return false;
        } else {
            $err = $this->client->getError();
            if ($err) {
                $this->errors = $err;

                return false;
            } else {
                return $result;
            }
        }
    }