Recupera gli argomenti dalla funzione stessa.
182471
def get_functarguments(func):
    
    argspec = inspect.getargspec(func)
    if argspec.defaults is not None:
        args = argspec.args[:-len(argspec.defaults)]
        kwargs = dict(
            zip(argspec.args[-len(argspec.defaults):], argspec.defaults))
    else:
        args = argspec.args
        kwargs = {}
    if args and args[0] == 'self':
        args.pop(0)
    func.__named__ = []
    arguments = []
    shared = get_shared(func)
    for arg in args:
        if has_shared(arg, shared) is not False:
            continue
        if has_argument(arg, func.__cls__) is not False:
            continue
        arguments.append(([arg], {}, ))
        func.__named__.append(arg)
    for key, val in kwargs.items():
        if has_shared(key, shared) is not False:
            continue
        if has_argument(key, func.__cls__) is not False:
            continue
        if isinstance(val, dict):
            flags = [val.pop('lflag', '--%s' % key)]
            short = val.pop('flag', None)
            dest = val.get('dest', key).replace('-', '_')
            if short:
                flags.insert(0, short)
        else:
            flags = ['--%s' % key]
            val = dict(default=val)
            dest = key.replace('-', '_')
        func.__named__.append(dest)
        arguments.append((flags, val, ))
    return arguments
1039470
function defineRoutes(app) {
	
	//NON-ADMIN route
	//prima considero le route dei siti degli utenti
	app.get('/:route?/:param0?/:param1?/:param2?/:param3?/:param4?/:param5?/:param6?/:param7?/:param8?/:param9?', app.jsl.perm.readStrucPermDefault, function(req, res, next)
	//app.get('/:route?', app.jsl.perm.readStrucPermDefault, function(req, res, next)
	{
		//non so perchè ma quando viene richiesto un file statico, le sessions non sono definite
		//quindi se non sono deifnite, deduco si tratti di un file statico, e skippo
		if ( !req.session )
		{
			next();
			//non faccio niente
			//console.log("negot per:"+req.url);
		}
		//se stanno chiamando un service json skippo oltre
		else if ( req.params.route == 'json' )
		{
			next();
			console.log('stanno chiamando un json, skippo oltre');
		}
		else{
			app.jsl.routes.routeInit(req);
			//console.log("vabè per:"+req.url);
			//console.log(req.headers.host);
			//console.log(req.url);
			//il sito di admin può anche girare su un ip, mentre i siti degli utenti (v.sotto) possono girare solo su un dominio
			//il dell'admin deve essere in una delle forme:
			//admindomain
			//admindomain:adminport
			//adminip
			//adminip:adminport
			if
			(
				req.headers.host == app.jsl.config.domain ||
				req.headers.host == app.jsl.config.domain+":"+app.jsl.config.port ||
				req.headers.host == app.jsl.config.ip ||
				req.headers.host == app.jsl.config.ip+":"+app.jsl.config.port
			)
			{
				//è stato richiesto il sito di admin, posso procedere nel processare le route di admin
				next();
			}
			else
			{
				//non è stato richiesto il sito di admin, controllo se è stato richiesto un sito pubblico
				//console.log('passo da qui'+req.session.loggedIn);
				//console.log(req);
				//prima però devo leggere i permessi
				//app.jsl.perm.readStrucPermDefault(req, res, function()
				//{
				//var express = require('express');
				//app.use(express.static(__dirname + '/public'));
				
				////if ( !req.session )
				////{
					////next();
					//////non faccio niente
				////}
				////else
				////{
				
					//controllo se esiste nel db il sito (host) richiesto
					var conditions = ( req.session.user_id == 'superadmin' ) 
					? 
					{
						'domain': req.headers.host
					}
					:
					{
						'domain': req.headers.host,
						$or: [
							{ 'status': 'public' }, 
							{ 'status': 'share' }, 
							{'author': req.session.user_id }
						]
					};
					//console.log('e qui'+req.session.loggedIn);
					app.jsl.site.findOne(
						conditions,
						function(err, site) {
							//console.log('e anche qui'+req.session.loggedIn);
							if ( !err )
							{
								if ( site )
								{
									//il sito richiesto esiste nel db
									/*
									res.render('debug', {
										layout: false, 
										variable: 'beccato sito: '+req.headers.host
									});
									*/
									//cerco tra tutte le pagine del sito permesse al mio utente una con la mia route
									//se la route è nulla, automaticamente uscirà la pagina di root
									//console.log('e anche qui pure'+req.session.loggedIn);
									var conditions = ( req.session.user_id == 'superadmin' ) 
									? 
									{
										'site': site.id,
										'route': ( req.params.route ) ? req.params.route : ''
										//'route': req.url.substring(1)
									} 
									: 
									{
										'site': site.id,
										'route': ( req.params.route ) ? req.params.route : '',
										//'route': req.url.substring(1), 
										$or: [
											{ 'status': 'share' }, 
											{ 'status': 'public' }, 
											{ 'author': req.session.user_id }
									]};
									app.jsl.page
										.findOne(
											conditions,
											[], 
											{}
										)
										.populate('site')
										.run(function(err, page) {
											//console.log('e anche qui pure forse'+req.session.loggedIn);
											if ( !err )
											{
												if ( page )
												{
													//console.log('e anche qui pure forse magari'+req.session.loggedIn);
													//ho trovato la pagina richiesta dall'utente
													//posso finalmente procedere a visualizzare la pagina
													
													//var pageController = require('../controllers/page');
													app.jsl.pageController.render( app, req, res, page );
													/* questo funzia
													res.render('debug', {
														layout: false, 
														variable: 'pagina: '+page.route+" del sito: "+site.domain
													});
													*/
												}
												else
												{
													app.jsl.utils.errorPage(res, err, "the page with route: '"+req.url+"' doesn't exist, or is private, on site: "+site.domain, 'layoutPopup');
													//non ho trovato la pagina, procedo, potrebbe essere stato richiesto un file statico
													//next();
												}
											}
											else
											{
												app.jsl.utils.errorPage(res, err, "error on query to find page: "+req.url, 'layoutPopup');
											}
										});							
								}
								else
								{
									app.jsl.utils.errorPage(res, err, "the site '"+req.headers.host+"' doesn't exist on this server, or is private", 'layoutPopup');
								}
							}
							else
							{
								app.jsl.utils.errorPage(res, err, "error on query to find site: "+req.headers.host, 'layoutPopup');
							}
						}
					);				
				////}
				//});
			}
		}
	}); 	
	
	
	
	
	
	
	//da qui in poi solo route del sito di admin
	
	
	//GET: home
	app.get('/', app.jsl.perm.readStrucPermDefault, function(req, res){ 
		app.jsl.routes.routeInit(req);
		res.render('home', {
		});
	});

	//POST: login signin
	app.post('/signin', function(req, res) {
		app.jsl.routes.routeInit(req);
		//controllo se esiste il mio utente nel db
		app.jsl.sess.checkValidUser(req, function(result, user_id) { 
			if ( result )
			{
				//ho trovato lo user nel db (oppure sono superadmin)
				//il login è valido
				app.jsl.sess.setSignedIn(req, user_id);
				console.log("POST: login signin: login succeded for user: "+req.body.login_email);
				//alla fine ricarico la pagina da cui arrivavo
				res.redirect('back');
			}
			else
			{
				//il mio utente non c'è nel db
				app.jsl.sess.setSignedOut(req);
				console.log("POST: login signin: login failed for user: "+req.body.login_email);
				//alla fine ricarico la pagina da cui arrivavo
				res.redirect('back');
			}
		});	
	});
	
	//GET: login signout
	app.get('/signout', function(req, res) {
		app.jsl.routes.routeInit(req);
		//resetto le session
		console.log("POST: login signout: for user: "+req.session.email);
		app.jsl.sess.setSignedOut(req);
		//alla fine ricarico la pagina da cui arrivavo
		res.redirect('back');
	});
	
	//GET: change language
	app.get('/lan/:locale?', function(req, res) {
		app.jsl.routes.routeInit(req);
		//cambio la lingua
		//req.session.currentLocale = req.params.locale;
		//console.log("prima nei cookie ho:");
		//console.log(req.cookies);
		res.cookie('currentlocale', req.params.locale, { expires: new Date(Date.now() + app.jsl.config.cookiesDurationMs), path: '/' });
		//console.log('dopo nei cookies ho: ');
		//console.log(req.cookies);
		//alla fine ricarico la pagina da cui arrivavo
		res.redirect('back');
	});
	
	//POST: qaptcha specific route
	app.post('/qaptcha', function(req, res) {
		app.jsl.routes.routeInit(req);
		console.log(req.body);
		var response = {};
		response['error'] = false;
			
		if(req.body.action && req.body.qaptcha_key)
		{
			req.session.qaptcha_key = false;	
			
			if(req.body.action == 'qaptcha')
			{
				req.session.qaptcha_key = req.body.qaptcha_key;
			}
			else
			{
				response['error'] = true;
			}
		}
		else
		{
			response['error'] = true;
		}
		res.json( response );
	});
	
	
	
	/*
	FILTERS
	nota: ora li tengo qui, ma se aumentano sarà meglio metterli, ove possibile, nei rispettivi controllers js
	*/
	
	//GET: list filter All or Mine
	app.get('/filterAllOrMine/:filterOn', function(req, res) {
		app.jsl.routes.routeInit(req);
		//posso filtrare sui miei elementi solo se sono loggato, e se non sono superadmin
		if ( req.session.loggedIn && req.session.user_id != 'superadmin' )
		{
			//sono loggato, non come superadmin, quindi posso filtrare
			req.session.filterAllOrMine = req.params.filterOn;
		}
		else if ( req.session.loggedIn && req.session.user_id == 'superadmin' )
		{
			//sono loggato come superadmin, non posso filtrare sui miei elementi ma solo su tutti
			req.session.filterAllOrMine = 'all';
		}
		else
		{
			//se invece sto cercando di attivare il filtering senza essere loggato, forzo un loagout che mi azzera tutte le sessions
			setSignedOut(req);
		}
		//alla fine ricarico la pagina da cui arrivavo
		res.redirect('back');
	});
	
	//GET: filter by site
	//nota: se si passa anche il parametro andGotoUrl, questo deve essere URIencodato: in jade usare #{encURI('url')}
	app.get('/filterBySite/:site?/:andGotoUrl?', function(req, res) {
		app.jsl.routes.routeInit(req);
		//prima definisco su che url fare il redirect
		var redirectTo = ( req.params.andGotoUrl != '' && req.params.andGotoUrl != undefined ) ? decodeURIComponent(req.params.andGotoUrl) : 'back';
		//inizialmente azzero la session per il filtraggio
		req.session.filterBySite = undefined;
		//verifico se mi è arrivato un site su cui filtrare
		if ( req.params.site != '' && req.params.site != undefined )
		{
			//leggo i siti su cui posso filtrare, per verificare che l'utente stia cercando di filtrare su un sito a lui consentito
			app.jsl.siteController.getSites(req,res,function(sites) {
				if (sites)
				{
					//posso filtrare su dei sites. verifico se quello richiesto è tra quelli papabili
					//nota: non posso usare array.forEach perchè devo poter usare break;
					for (var x=0;x<sites.length;x++)
					{
						if ( sites[x]._id == req.params.site )
						{
							//trovato il mio sito, posso usarlo per filtrare
							//imposto le session ed esco dal ciclo
							req.session.filterBySite = req.params.site;
							break;
						}
					}
					//ricarico la pagina da cui arrivavo
					res.redirect(redirectTo);				
				}
				else
				{
					//se non mi sono arrivati sites, vuol dire che non posso filtrare su niente
					//ricarico la pagina da cui arrivavo
					res.redirect(redirectTo);				
				}
			});
		}
		else
		{
			//non mi è arrivato il site, che vuol dire che non devo filtrare su nessun site
			//ricarico la pagina da cui arrivavo
			res.redirect(redirectTo);
		}
	});

	/*	
	//GET: filter by model
	//nota: se si passa anche il parametro andGotoUrl, questo deve essere URIencodato: in jade usare #{encURI('url')}
	app.get('/filterByModel/:jslModel?/:andGotoUrl?', function(req, res) {
		app.jsl.routes.routeInit(req);
		//prima definisco su che url fare il redirect
		var redirectTo = ( req.params.andGotoUrl != '' && req.params.andGotoUrl != undefined ) ? decodeURIComponent(req.params.andGotoUrl) : 'back';
		//inizialmente azzero la session per il filtraggio
		req.session.filterByModel = undefined;
		//verifico se mi è arrivato un jslModel su cui filtrare
		if ( req.params.jslModel != '' && req.params.jslModel != undefined )
		{
			//leggo i siti su cui posso filtrare, per verificare che l'utente stia cercando di filtrare su un sito a lui consentito
			app.jsl.jslModelController.getJslModels(req,res,function(jslModels) {
				if (jslModels)
				{
					//posso filtrare su dei jslModels. verifico se quello richiesto è tra quelli papabili
					//nota: non posso usare array.forEach perchè devo poter usare break;
					for (var x=0;x<jslModels.length;x++)
					{
						if ( jslModels[x]._id == req.params.jslModel )
						{
							//trovato il mio sito, posso usarlo per filtrare
							//imposto le session ed esco dal ciclo
							req.session.filterByModel = req.params.jslModel;
							break;
						}
					}
					//ricarico la pagina da cui arrivavo
					res.redirect(redirectTo);				
				}
				else
				{
					//se non mi sono arrivati jslModels, vuol dire che non posso filtrare su niente
					//ricarico la pagina da cui arrivavo
					res.redirect(redirectTo);				
				}
			});
		}
		else
		{
			//non mi è arrivato il jslModel, che vuol dire che non devo filtrare su nessun jslModel
			//ricarico la pagina da cui arrivavo
			res.redirect(redirectTo);
		}
	});
	*/

	
	
}
1129372
public function dispatchAction()
    {
        //pobranie kategorii
        $category = $this->_getPublishedCategoryByUri($this->uri);
        //wpięcie kategorii do głównego widoku aplikacji
        FrontController::getInstance()->getView()->category = $category;
        //klucz bufora
        $cacheKey = 'category-html-' . $category->id;
        //buforowanie dozwolone
        $bufferingAllowed = $this->_bufferingAllowed();
        //wczytanie zbuforowanej strony (dla niezalogowanych i z pustym requestem)
        if ($bufferingAllowed && (null !== $html = \App\Registry::$cache->load($cacheKey))) {
            //wysyłanie nagłówka o buforowaniu strony
            $this->getResponse()->setHeader('X-Cache', 'HIT');
            //zwrot html
            return $this->_decorateHtmlWithEditButton($html, $category);
        }
        //wysyłanie nagłówka o braku buforowaniu strony
        $this->getResponse()->setHeader('X-Cache', 'MISS');
        //przekazanie rekordu kategorii do widoku
        $this->view->category = $category;
        //renderowanie docelowej akcji
        $html = \Mmi\Mvc\ActionHelper::getInstance()->forward($this->_prepareForwardRequest($category));
        //buforowanie niedozwolone
        if (!$bufferingAllowed || 0 == $cacheLifetime = $this->_getCategoryCacheLifetime($category)) {
            //zwrot html
            return $this->_decorateHtmlWithEditButton($html, $category);
        }
        //zapis html kategorii do cache
        \App\Registry::$cache->save($html, $cacheKey, $cacheLifetime);
        //zwrot html
        return $this->_decorateHtmlWithEditButton($html, $category);
    }
973309
private List<?> joinFeatures(List<?> list) {
        List result = new ArrayList<Object>();

        for (Object object : list) {
            int start = -1;
            int end = -1;

            if (object instanceof Gene) {
                result.add(object);
                start = ((Gene) object).getStart();
                end = ((Gene) object).getEnd();
            }

            if (object instanceof RegulatoryRegion) {
                result.add(object);
                start = ((RegulatoryRegion) object).getStart();
                end = ((RegulatoryRegion) object).getEnd();
            }

            if (object instanceof List) {
                result.addAll(joinFeatures((List) object));
            }

            /* Acutualizamos los valores maximo de end y minimo de start */
            if ((start != -1) && (start < min_start)) {
                min_start = start;
            }

            if ((end != -1) && (end > max_end)) {
                max_end = end;
            }
        }

        return result;
    }
537518
def enviar_dados_venda(self, dados_venda):
        
        retorno = super(ClienteSATLocal, self).enviar_dados_venda(dados_venda)
        return RespostaEnviarDadosVenda.analisar(retorno)
292136
function getPeriodoSala (periodo) {
  assert.ok(typeof periodo === 'number' || periodo instanceof Date, '[senadores-asistencia]: El periodo ingresado debe ser un número o una fecha.')

  let _period = {}
  if (typeof periodo === 'number') {
    _period = periods.filter(period => period.legislatura === periodo)
    // search directly by period id
    if (_period.length > 0) return _period[0]
    // search only by year
    _period = periods.filter(period => {
      return period.desde.getFullYear() <= periodo && periodo <= period.hasta.getFullYear()
    })[0]
    assert.ok(_period, '[senadores-asistencia]: Periodo de busqueda no encontrado')
    console.warn('[senadores-asistencia]: Solo se puede consultar por periodo legislativo. Si para un mismo año existe más de un periodo legislativo, solo se obtendran los resultados del primer periodo encontrado, por lo que jamas se obtendran los periodos posteriores en caso de existir. Prefiera busquedas por fecha o id de legislatura.')
    return _period
  }
  if (periodo instanceof Date) {
    // search by date
    _period = periods.filter(period => {
      return period.desde.getTime() <= periodo.getTime() && periodo.getTime() <= period.hasta.getTime()
    })[0]
    assert.ok(_period, '[senadores-asistencia]: Periodo de busqueda no encontrado')
    return _period
  }
}
788292
def view_getApplicationsAssetsItems
      return VIEW_APPASSETS if defined? VIEW_APPASSETS
      # inizializzo la lista delle voci della navbar
      assets = []
      directory = core_getCacheDirectory
      if File.exist? "#{directory}/view.yml"
        # accedo al view.yml
        config = YAML.load(
          File.read(File.expand_path("#{directory}/view.yml", __FILE__))
        )
        # estraggo i dati dallo yaml
        data = getConfigAssets(config)
        # aggiungo i dati nella risposta
        data.each do |single_asset|
          assets.push(single_asset)
        end
      end
      # ritorno il risultato
      return assets
    end
781705
def Guardar(self, tipo_doc, nro_doc, denominacion, cat_iva, direccion, 
               email, imp_ganancias='NI', imp_iva='NI', monotributo='NI', 
               integrante_soc='N', empleador='N'):
        ""
        if self.Buscar(nro_doc, tipo_doc):
            sql = ("UPDATE padron SET denominacion=?, cat_iva=?, email=?, "
					"imp_ganancias=?, imp_iva=?, monotributo=?, "
					"integrante_soc=?, empleador=? "
                    "WHERE tipo_doc=? AND nro_doc=?")
            params = [denominacion, cat_iva, email, imp_ganancias, 
                      imp_iva, monotributo, integrante_soc, empleador,
                     tipo_doc, nro_doc]
        else:
            sql = ("INSERT INTO padron (tipo_doc, nro_doc, denominacion, "
                    "cat_iva, email, imp_ganancias, imp_iva, monotributo, "
                    "integrante_soc, empleador) "
                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
            params = [tipo_doc, nro_doc, denominacion, cat_iva, email,
                      imp_ganancias, imp_iva, monotributo, 
                      integrante_soc, empleador]
        self.cursor.execute(sql, params)
        # agregar el domicilio solo si no existe:
        if direccion:
            self.cursor.execute("SELECT * FROM domicilio WHERE direccion=? "
                                "AND tipo_doc=? AND nro_doc=?", 
                                [direccion, tipo_doc, nro_doc])
            if self.cursor.rowcount < 0:
                sql = ("INSERT INTO domicilio (nro_doc, tipo_doc, direccion)"
                        "VALUES (?, ?, ?)")
                self.cursor.execute(sql, [nro_doc, tipo_doc, direccion])
        self.db.commit()
        return True
417572
def analisar(retorno):
        
        resposta = analisar_retorno(forcar_unicode(retorno),
                funcao='ConsultarStatusOperacional',
                classe_resposta=RespostaConsultarStatusOperacional,
                campos=RespostaSAT.CAMPOS + (
                        ('NSERIE', as_clean_unicode),
                        ('TIPO_LAN', as_clean_unicode),
                        ('LAN_IP', normalizar_ip),
                        ('LAN_MAC', unicode),
                        ('LAN_MASK', normalizar_ip),
                        ('LAN_GW', normalizar_ip),
                        ('LAN_DNS_1', normalizar_ip),
                        ('LAN_DNS_2', normalizar_ip),
                        ('STATUS_LAN', as_clean_unicode),
                        ('NIVEL_BATERIA', as_clean_unicode),
                        ('MT_TOTAL', as_clean_unicode),
                        ('MT_USADA', as_clean_unicode),
                        ('DH_ATUAL', as_datetime),
                        ('VER_SB', as_clean_unicode),
                        ('VER_LAYOUT', as_clean_unicode),
                        ('ULTIMO_CF_E_SAT', as_clean_unicode),
                        ('LISTA_INICIAL', as_clean_unicode),
                        ('LISTA_FINAL', as_clean_unicode),
                        ('DH_CFE', as_datetime_or_none),
                        ('DH_ULTIMA', as_datetime),
                        ('CERT_EMISSAO', as_date),
                        ('CERT_VENCIMENTO', as_date),
                        ('ESTADO_OPERACAO', int),
                    ),
                campos_alternativos=[
                        # se falhar resultarão apenas os 5 campos padrão
                        RespostaSAT.CAMPOS,
                    ]
            )
        if resposta.EEEEE not in ('10000',):
            raise ExcecaoRespostaSAT(resposta)
        return resposta
1254498
public function dispatch()
	{
		// prendi l'uri corrente priva di argomenti get
		$current_uri = $this->base_uri();
		// memorizza il metodo corrente
		$current_method = $this->method();

		foreach($this->routes as $route)
		{
			// confronta l'uri corrente con
			// la rotta, se corrispondono 
			// eseguila
			if($route->match($current_uri, $current_method, $this->rules))
			{
				return $route->call($this->namespaces);
			}
		}
		return false;
	}
592588
public function getStatement() {
        
        $response = [];
        
        //iegūst visus datus un sakārto tos smukā masīvā
        foreach ($this->accountList as $account) {
            $currencyList = $account->getCurrencies();
            $accountName = $account->name();
            
            foreach ($currencyList as $currency) {
                $trxList = $currency->getTransactions();
                $currencyName = $currency->name();

                foreach ($trxList as $trx) {
                    //sākam paša masīva formēšanu
                    $response[] = $this->getStatementRow($trx, $currencyName, $accountName);
                }
            }
        }
        return $response;
    }
1056884
def recurse(*cls):
    
    def wrap(f):
        def wrapped_f(tlist):
            for sgroup in tlist.get_sublists():
                if not isinstance(sgroup, cls):
                    wrapped_f(sgroup)
            f(tlist)

        return wrapped_f

    return wrap
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]
889299
def AgregarDatoPDF(self, campo, valor, pagina='T'):
        ""
        # corrijo path relativo para las imágenes (compatibilidad hacia atrás):
        if campo == 'fondo' and valor.startswith(self.InstallDir):
            if not os.path.exists(valor):
                valor = os.path.join(self.InstallDir, "plantillas", os.path.basename(valor))
            if DEBUG: print "NUEVO PATH:", valor          
        self.datos[campo] = valor
        return True
1234241
function(nombre, controlador, tags, opciones) {
    // Se establecen los objetos comunes a todos los dispositivos
    this.info = Object();
    this.info.nombre = nombre;
    this.conectado = false;
    this.noErrores = true;
    this.cola = new objCola();
    this.funciones = new funciones(this);
    this.log = new log(this.info.nombre);
    this.tags = tags;
    this.tiposMB = {
        BYTE: {bits: 8, funcion: 'Int8', endian: false},
        INT: {bits: 16, funcion: 'Int16', endian: true},
        UINT: {bits: 16, funcion: 'UInt16', endian: true},
        DINT: {bits: 32, funcion: 'Int32', endian: true},
        UDINT: {bits: 32, funcion: 'UInt32', endian: true}, 
        FLOAT: {bits: 32, funcion: 'Float', endian: true},
        DOUBLE: {bits: 64, funcion: 'Double', endian: true}
    }
    new require('./drivers/'+controlador+'/driver') (this); // Se integran las funciones del driver con el dispositivo actual
    utilidades.mezclarObjetos(opciones, this.info); // Se establecen los objetos particulares de cada dispositivo
    
    this.conectarRecursiva(); // Se conecta el dispositivo
    
    
    
    
    /*
     * Se establecen los eventos o Listeners que serán ejecutados en TODOS los dispositivos, sean del driver que sea
     */
    utilidades.eventos(this, {
        conexion: function() {
            this.conectado = true;
            this.comenzarCiclo();
            this.comprobarConexion();
            
            this.log.info("Conectado");
            this.emit("conectado");
        },
        desconexion: function() {
            if (this.conectado) {
                this.conectado = false;
               
                this.cola.vaciar();
                
                this.log.error("Desconectado");
                this.emit("desconectado");
                this.conectarRecursiva();
            }
        },
        datosRecibidos: function(datos) {
            var buffer = utilidades.extractorBuffer(datos, this.estructuraCabecera, this.tiposMB, this.bytesPorPosicion, this.endian, this.noErrores);   
            if (typeof this.cola.operaciones[buffer.operacion] === 'undefined') {
                this.cola.prepararCola();
                return false;
            }
            
            var numOperacion = buffer.operacion;
            var operacion = this.cola.operaciones[numOperacion];
            var numPaquete = operacion.paquete;
            var paquete = this.cola.paquetes[numPaquete];

            if ((paquete.operaciones.lastIndexOf(numOperacion) === -1) || (typeof this.funciones[paquete.funcion+"Callback"] === 'undefined')) {
                this.cola.prepararCola();
                return false;
            }
            
            var informacion = this.funciones[paquete.funcion+"Callback"](buffer, numOperacion, operacion, numPaquete, paquete);            
            if (paquete.operaciones.length == 1) {
                if (this.cola.quitarPaquete(numPaquete)) {
                    if (typeof paquete.callback == 'function') {
                        if (typeof informacion == 'object') {
                            var array = utilidades.obj2arr(informacion);
                        }

                        paquete.callback.apply(this, array);
                    }
                }
            } else {
                this.cola.quitarOperacion(numOperacion);
            }
            
            this.cola.prepararCola();
            return true;
        },
        error: function() {
            if (this.conectado) {
                this.log.error("Se ha producido un error. Reconectamos el dispositivo...");
                this.emit("desconexion");
            }
        }
    });

    // Alias para los eventos
    this.on("conectado", function() {
        this.emit("connected");
    });
    this.on("desconectado", function() {
        this.emit("disconnected");
    });
    
    
    events.call(this); // Función de llamada a los eventos personalizados
}
618206
def cancelar_ultima_venda(self, chave_cfe, dados_cancelamento):
        
        resp = self._http_post('cancelarultimavenda',
                chave_cfe=chave_cfe,
                dados_cancelamento=dados_cancelamento.documento())
        conteudo = resp.json()
        return RespostaCancelarUltimaVenda.analisar(conteudo.get('retorno'))
722046
function populateContentModel(app, req, res, content, contentData, contentFiles, next) {
	/*
	console.log('###### populateContentModel:');
	console.log('content:');
	console.log(content);
	console.log('contentData:');
	console.log(contentData);
	*/
	
	//trovo il modelId (dipende se mi passano un content con il field jslModel già popolato o meno)
	if ( content.jslModel._id ) {
		var modelId = content.jslModel._id;
	} else {
		var modelId = content.jslModel;
	}
	
	//leggo dal db il mio model, per avere lo schema
	app.jsl.jslModel.findOne( { '_id': modelId } )
	.run( function(err, jslModel) {
		if (!err)
		{
			if ( jslModel ) {
				//trovato lo schema
				var schema = JSON.parse(jslModel.jslSchema);
				/*
				console.log('trovato lo schema!');
				console.log(schema);
				*/
				//ciclo su ogni field, e popolo solo quelli nel content
				for(var field in schema) {
					//non devo mai popolare alcuni field interni di jslardo, perchè non vengono gestiti dal form
					if ( field == 'author' || field == 'created' ) {
						//skippo
					} else {
						/*
						console.log('### considero il field: '+field);
						console.log('content[field]: '+content[field]);
						console.log('contentData[field]: '+contentData[field]);
						*/
						//prima distinguo a seconda che sia un field array o a valore singolo
						if ( is_array( schema[field] ) ) {
							//è un array, per ora gestisco solo valori separati da virgola, perchè mi aspetto solo degli ObjectIds
							//console.log(field+' è un array!');
							if ( contentData[field] ) {
								content[field] = contentData[field].split(',');
							} else {
								//content[field] = null;
								delete content[field]; //tanto non serve a un cazzo perchè mongodb non resetta il field
							}
							/*
							//per ogni ObjectId devo istanziare la relativa istanza, e aggiungerla al mio content
							var ObjectIds = contentData[field].split(',');
							for ( var i = 0; i < ObjectIds.length; i++ ) {
								content[field].push( ObjectIds[i] );
							}
							*/
						} else {
							//non è un array, fisso il suo valore
							//console.log(field+' è un single!');
							//distinguo a seconda del datatype
							switch ( schema[field].type ) {
								case 'ObjectId':
									//nel caso degli ObjectId non assegno un field se non ha l'ObjectId definito
									if ( contentData[field] ) {
										content[field] = contentData[field];
									} else {
										//content[field] = null;
										delete content[field]; //tanto non serve a un cazzo perchè mongodb non resetta il field
									}
									break;
								case 'Boolean':
									//porcheria per gestire i valori boolean
									//il form tratta tutto come string mentre lo schema mongoose è tipizzato
									//quandi un 'false' che arriva da un form diventerebbe un true nel db in quanto stringa non vuota castata a boolean
									if ( contentData[field] == 'sure_this_is_true' ) {
										content[field] = true;
									} else if ( contentData[field] == 'sure_this_is_false' ) {
										content[field] = false;
									} else {
										content[field] = contentData[field];
									}
									break;
								case 'Image':
									//console.log('tinculo!');
									/*
									(se nessun file è stato uploadto, è tutto uguale, tranne size:0, name:'', lastModifiedDate:null )
									contentFiles:
									{ foto: 
										{ 	size: 760,
											path: 'public/uploads/b89e47bbef608847129906e6b875c7a5',
											name: 'package.json',
											type: 'application/octet-stream',
											lastModifiedDate: Mon, 13 Feb 2012 02:42:55 GMT,
											_writeStream: 
											{ 	path: 'public/uploads/b89e47bbef608847129906e6b875c7a5',
												fd: 14,
												writable: false,
												flags: 'w',
												encoding: 'binary',
												mode: 438,
												busy: false,
												_queue: [],
												drainable: true
											},
											length: [Getter],
											filename: [Getter],
											mime: [Getter]
										}
									}
									*/
									/* invece content, secondo lo schema del datatype Image, dovrebbe essere una roba tipo
									content:
									{ foto:
										[ {
											'file_name': 	{ type: String },
											'file_path': 	{ type: String },
											'file_type': 	{ type: String },
											'file_size': 	{ type: Number },
											'file_date':{ type: Date },
											'width': 		{ type: Number },
											'height': 		{ type: Number }
										} ]
									}
									*/
									
									//controllo se effettivamente è stato uploadato un file
									if ( contentFiles[field].name != '' &&  contentFiles[field].size > 0 ) {
										//c'è il file
										//prima devo spostare il file nella sua posizione definitiva
										//console.log('sposto file');
										var from = process.cwd()+'/'+contentFiles[field].path;
										//var to = process.cwd()+'/public/'+getContentPath(modelId,content._id)+contentFiles[field].name;
										var to = process.cwd()+'/public/'+getContentPath(modelId,content._id);
										var fs = require('fs');
										//console.log(from);
										//console.log(to);
										var statsFrom = fs.lstatSync(from);
										//console.log(from + ": is a file? " + statsFrom.isFile());										
										//console.log(from + ": is a directory? " + statsFrom.isDirectory());										
										//se la dir non esiste, la creo
										try
										{
											var statsTo = fs.lstatSync(to);
											//console.log(to + ": is a file? " + statsTo.isFile());										
											//console.log(to + ": is a directory? " + statsTo.isDirectory());										
											//console.log('la dir to esiste già');
										}
										catch (e)
										{
											//la dir non esiste
											//console.log('la dir to non esiste');
											//la creo
											mkPath(to);
										}
										
										//sposto il file
										fs.renameSync(from, to+contentFiles[field].name);
										
										//poi posso popolare il content[field]
										var contentField = {};
										contentField.file_name = contentFiles[field].name;
										contentField.file_path = getContentPath(modelId,content._id);
										contentField.file_type = contentFiles[field].type;
										contentField.file_size = contentFiles[field].size;
										contentField.file_date = contentFiles[field].lastModifiedDate;
										//assegno come array, perchè così vuole lo schema
										content[field] = [ contentField ];
									} else {
										//nessun file uplodato
										//il mio contentField non viene popolato
									}
									break;
								default:
									content[field] = contentData[field];
									break;
							}
						}
						/*
						console.log('dopo assegnamento content['+field+']: ');
						console.log(content[field]);
						*/
					}
				}
				/*
				console.log('###### populateContentModel alla fine:');
				console.log('content:');
				console.log(content);
				console.log('contentData:');
				console.log(contentData);
				*/
				//finito di popolare
				next();
				
				
				
			} else {
				console.log("populateContentModel(): element not found");
			}	
		} else {
			console.log("populateContentModel(): failed query to retrieve element");
		}	
			
	});	
	//var jsonSchema = JSON.parse(contentData.jsonModel.jslSchema);
	//console.log('jsonSchema:');
	//console.log(jsonSchema);
}