questo metodo viene richiamato prima di eseguire ogni request che lo richiede in qualunque controller di qualunque oggetto
516057
function readStrucPerm(on, req, res, next) {
	//console.log('readStrucPerm: req.session.user_id = ' + req.session.user_id);
	//solo nel caso di favicon.ico non ha le session impostate, non so perchè,
	//quindi bypasso il controllo, perchè su favicon non ho nessuna restrizione
	if ( !req.session )
	{
		next();
	}
	else
	{
		//azzero i permessi
		req.session.loggedIn = false;
		req.session.canCreate = false;
		req.session.canModify = false;
		req.session.canModifyMyself = false; //questo è un permesso che vale solo per l'elemento "users"
		//controllo se sono loggato
		if (req.session.user_id) {
			//l'utente risulta loggato
			//controllo se i suoi dati di login sono validi
			//(questo controllo va fatto ogni volta, perchè se dall'ultimo conrollo l'utente fosse stato cancellato, non me ne accorgerei senza controllo
			req.app.jsl.sess.checkValidUser(req, function(result, user_id) { 
				if ( result )
				{
					//i dati di login sono validi
					req.session.loggedIn = true;
					if ( user_id == 'superadmin' )
					{
						//se sono super admin, ho sempre permesso di modify su tutti i contenuti, ma non ho il create (a parte sugli users)
						//questo perchè quando si crea un contenuto, questo è strettamente legato all'utente che lo crea, e il superadmin
						//non è un utente vero è proprio (non è presente nel db, non ha id). il super admin serve solo per poter vedere e modificare tutto, ma non può creare nulla
						req.session.canModify = true;
						req.session.canModifyMyself = true; //questo serve per permettere al super admin di modificare gli utenti (il form di modifica lo richiede)
						//solo nel caso degli users, il superadmin ha il create, anche se usersCanRegister = false
						if ( on == 'user' )
						{
							req.session.canCreate = true;
						}
						//la request puo essere processata
						next();
					}
					else
					{
						//non sono superadmin
						//siccome si tratta di permessi su elementi della struttura, chiunque (loggato) ha sempre il permesso di create nuovi elementi
						//(tranne per il caso degli "user" in cui si creano altri utenti con il bottone "registrati", che però non prevede di essere loggati)
						if ( on != 'user' )
						{
							req.session.canCreate = true;
						}
						//differenzio i permessi di modify in base all'oggetto trattato
						switch (on)
						{
							case 'user':
								//user è un elemento della struttura particolare, perchè, a differenza di tutti gli altri elementi di struttura, ogni utente può solo modificare
								//se stesso. inoltre user non ha un "author" poichè un utente è creato da se stesso tramite il bottone "register"
								//nel caso di modifica di users, ho modify solo per modificare me stesso
								if ( req.params.id == req.session.user_id ) //controllo se l'id dell'utente da modificare è quello dell'utente loggato, cioè se modifico me stesso
								{
									//lo user id nella route richiesta corrisponde al mio, quindi posso modificare me stesso (il mio profilo)
									req.session.canModifyMyself = true; 
								}
								break;
							default:
								//ora come ora per tutti gli altri elementi della struttura chiunque ha permesso di modify, ma solo sui propri elementi
								req.session.canModify = true; 
								break;
						}
						//continuo
						next();
						
					}
				}
				else
				{
					//i dati di login non sono validi
					//console.log('readStrucPerm: login NON valido');
					//forzo un logout (potrebbe verificarsi il caso in cui un utente è loggato, e viene cancellato dal db. in quel caso deve avvenire anche il suo logout)
					setSignedOut(req);
					//vengo mandato in home
					res.redirect('/');
				}
			});
			
		} else {
			//console.log('readStrucPerm: utente non loggato');			
			//non sono loggato. l'unica cosa che posso fare è di registrarmi, ovvero creare un nuovo user
			//ma solo se è stato previsto nel config
			if ( on == 'user' && req.app.jsl.config.usersCanRegister )
			{
				req.session.canCreate = true;
			}
			//non ho nessun permesso, continuo
			next();
		}
	}
}
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);
    }
1007868
def to_request
      dados_usuario = {
        codigo_cliente:             self.codigo_cliente,
        tipo_cliente:               self.tipos_de_cliente_to_request,
        nome_comprador:             self.nome,
        documento_comprador:        self.documento,
        documento_2_comprador:      self.documento_2,
        sexo_comprador:             self.sexo_to_request,
        data_nascimento_comprador:  self.data_nascimento,
        email_comprador:            self.email,
      }
      # Adiciona os dados de endereços
      dados_usuario.merge! self.endereco_comprador.to_request("endereco_comprador") unless endereco_comprador.blank?
      dados_usuario.merge! self.endereco_entrega.to_request("endereco_entrega") unless endereco_entrega.blank?

      # Adiciona os dados de telefones
      dados_usuario.merge! self.telefone_comprador.to_request("comprador") unless telefone_comprador.blank?
      dados_usuario.merge! self.telefone_adicional_comprador.to_request("adicional_comprador") unless telefone_adicional_comprador.blank?
      dados_usuario.merge! self.telefone_entrega.to_request("entrega") unless telefone_entrega.blank?
      dados_usuario.merge! self.telefone_adicional_entrega.to_request("adicional_entrega") unless telefone_adicional_entrega.blank?

      return dados_usuario
    end
999577
public function getList($params = array(), ServiceManager $sm) 
	{
		//var_dump($params); exit();
		$paginator = $this->getPaginator($params);
		
		$data = array();
		foreach($paginator as $post) {
			$data[] = $this->get($post, $sm); // verificare che cazzo fa sto get!!!!!
		}

		// Denormalizzazione parametri per creazione url da route
		$queryParams = array();
		$routeParams = array();
		$fields = isset($params['field']) ? array_values($params['field']) : array();
		$values = isset($params['value']) ? array_values($params['value']) : array();
		foreach($fields as $key => $field) {
			if(in_array($field, array('location', 'purpose', 'category'))) {
				$routeParams[$field] = $values[$key];
				continue;
			}
			$queryParams[$field] = $values[$key];
		}
		
		// remove user key from params if exists and if length 40 
		// (sha1 hash) add current
		$routeName = 'DocumentRegex/type/category/page';
		if(array_key_exists('account', $queryParams) && 40 == strlen($queryParams['account'])) {
			unset($queryParams['account']);
			$queryParams['current'] = true;
			$routeName = 'DocumentAccount/page';
		}
		
		return $this->getPaginationData($sm, $paginator, $data, $routeName, $routeParams, $queryParams);
	}
560864
public static function dispatch()
    {
        $vars = [];

        $request = Request::createFromGlobals();

        $dispatcher = new Dispatcher(static::instance()->getData());
        $routeInfo = $dispatcher->dispatch(
            $request->getMethod(),
            $request->getUri()->getPath()
        );

        $controller = "\\Barebone\\Controller";
        $action = "index";

        switch ($routeInfo[0]) {
        case Dispatcher::NOT_FOUND:
            $action = 'routerError';
            $vars['error'] = static::ERR_NOT_FOUND;
            $vars['subject'] = $request->getUri()->getPath();
            break;

        case Dispatcher::METHOD_NOT_ALLOWED:
            $action = 'routerError';
            $vars['error'] = static::ERR_BAD_METHOD;
            $vars['subject'] = $routeInfo[1];
            break;

        case Dispatcher::FOUND:
            $handler = $routeInfo[1];
            $vars = $routeInfo[2];

            if (!class_exists($handler[0])) {
                $action = 'routerError';
                $vars['error'] = static::ERR_MISSING_CONTROLLER;
                $vars['subject'] = $handler[0];
            } elseif (!method_exists($handler[0], $handler[1])) {
                $action = 'routerError';
                $vars['error'] = static::ERR_MISSING_ACTION;
                $vars['subject'] = $handler[0] . '::' . $handler[1];
            } else {
                $controller = $handler[0];
                $action = $handler[1];
            }
            break;
        }

        // Start with an empty response
        $response = new Response();
        $request->setAction($action);

        // @var Controller $instance
        $instance = new $controller($request, $response);
        $instance->initController();

        // Get Middleware stacks
        $before = $instance->getMiddlewareBefore();
        $after = $instance->getMiddlewareAfter();

        // Append the action call to the middleware stack
        $before[] = function (Request $request, Response $response,
            callable $next = null
        ) use ($instance, $action, $vars) {

            // assigned updated objects
            $instance->setRequest($request);
            $instance->setResponse($response);

            // get updated response from action
            $response = call_user_func_array([$instance, $action], $vars);

            // continue
            return $next($instance->getRequest(), $response);
        };

        // Run the middleware stack and return the Response
        $middlewares = array_reverse(array_merge($before, $after));
        $runner = \Sirius\Middleware\Runner::factory($middlewares);

        return $runner($request, $response);
    }
623874
def item_controller(self):
        """"""
        return StartActionItemController(
            self,
            self.raw,
            self.state,
            self.path,
            self.devices_dict)
845520
def get(self, url, controller):
        

        self.request_type = 'GET'
        controller_class, controller_method = self.__return_controller__(controller)

        self.controller = controller_class
        self.method = controller_method
        self.url_ = url

        self.url.append((url, controller_class, dict(method=controller_method, request_type=self.request_type, middleware=None)))
        return self
168527
public function mappingController($uriapp = NULL, $method = NULL){
        $controllers= $this->app->context->getControllersDefinition();
        $maps= FALSE;
        //Recorre todos los controladores principales hasta que uno coincida con la URI actual
        foreach ($controllers as $url => $controller_esp) {            
            //Analiza si el controlador mapea con la uri actual
            $controller_esp['url']= strpos($url, '@') ? substr($url, 0, strpos($url, '@')) : $url;
            
            $mapController= $this->mapsController($controller_esp, $uriapp, $method);
            if($mapController == NULL && isset($controller_esp['routes'])){
                foreach ($controller_esp['routes'] as $url => $controller_esp_2) {
                    $controller_esp_2['url']= strpos($url, '@') ? substr($url, 0, strpos($url, '@')) : $url;
                    $mapController= $this->mapsController($controller_esp_2, $uriapp, $method, $controller_esp);
                    if($mapController != NULL){
                        break;
                    }
                }
            }
            if($mapController != NULL){
                return $mapController;
            }           
        }
        //si ningun controlador mapeo avisa el problema
        if(! $maps){
            Error::error_404();
        }
    }
1060130
def to_request tipo
      telefone = {}
      case tipo.to_sym
        when :comprador then
          telefone = {
            codigo_tipo_telefone_comprador:   self.codigo_tipo_telefone_to_request,
            telefone_comprador:               self.telefone,
            ddd_comprador:                    self.ddd,
            ddi_comprador:                    self.ddi,
          }
        when :adicional_comprador then
          telefone = {
            codigo_tipo_telefone_adicional_comprador:   self.codigo_tipo_telefone_to_request,
            telefone_adicional_comprador:               self.telefone,
            ddd_adicional_comprador:                    self.ddd,
            ddi_adicional_comprador:                    self.ddi,
          }
        when :entrega then
          telefone = {
            codigo_tipo_telefone_entrega:   self.codigo_tipo_telefone_to_request,
            telefone_entrega:               self.telefone,
            ddd_entrega:                    self.ddd,
            ddi_entrega:                    self.ddi,
          }
        when :adicional_entrega then
          telefone = {
            codigo_tipo_telefone_adicional_entrega:   self.codigo_tipo_telefone_to_request,
            telefone_adicional_entrega:               self.telefone,
            ddd_adicional_entrega:                    self.ddd,
            ddi_adicional_entrega:                    self.ddi,
          }
        else
          raise 'Tipo inválido.'
      end
      return telefone
    end
397133
function Request_handleController(controllersPath, viewsPath) {
        var controllerToLoad = controllersPath + this.controller,
            LoadedController,
            controller,
            action,
            promise;

        try {
            LoadedController = di.load(controllerToLoad);
        } catch (e) {
            throw new error.HttpError(500, {path: controllerToLoad}, 'Missing controller', e);
        }

        if (!Type.assert(Type.FUNCTION, LoadedController)) {
            throw new error.HttpError(500, {path: controllerToLoad}, 'Controller must be function type');
        }

        controller = new LoadedController(this._getApi(), {
            controller: this.controller,
            action: this.action,
            module: this.module,
            url: this.url,
            id: this.id,
            viewsPath: viewsPath
        });

        if (!(controller instanceof  ControllerInterface)) {
            throw new error.HttpError(500, controller, 'Controller must be instance of ControllerInterface "core/controller"');
        }

        logger.info('Controller:', {
            controller: controller.__dynamic__,
            controllerToLoad: controllerToLoad,
            route: this._getRouteInfo()
        });

        if (controller.has("beforeEach")) {
            promise = this._chain(null, controller.beforeEach.bind(controller, this.action, this.params));
        }

        if (controller.has('before_' + this.action)) {
            promise = this._chain(promise, controller.get('before_' + this.action).bind(controller, this.params));
        }

        if (controller.has('action_' + this.action)) {
            promise = this._chain(promise, controller.get('action_' + this.action).bind(controller, this.params));
        } else {
            throw new error.HttpError(500, {
                controller: controller,
                hasAction: controller.has(this.action),
                route: this._getRouteInfo()
            }, 'Missing action in controller');
        }


        if (controller.has('after_' + this.action)) {
            promise = this._chain(promise, controller.get('after_' + this.action).bind(controller, this.params));
        }

        if (controller.has("afterEach")) {
            promise = this._chain(promise, controller.afterEach.bind(controller, this.action, this.params));
        }

        this.onEnd(controller.destroy.bind(controller));

        return promise;
    }
491814
def connect(self):
        ""

        #
        # source_address é atributo incluído na versão 2.7 do Python
        # Verificando a existência para funcionar em versões anteriores à 2.7
        #
        if hasattr(self, 'source_address'):
            sock = socket.create_connection((self.host, self.port), self.timeout, self.source_address)
        else:
            sock = socket.create_connection((self.host, self.port), self.timeout)

        if self._tunnel_host:
            self.sock = sock
            self._tunnel()

        if sys.version_info >= (2,7,13):
            self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=ssl.PROTOCOL_TLS, do_handshake_on_connect=False)
        else:
            self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=ssl.PROTOCOL_SSLv23, do_handshake_on_connect=False)
944314
protected function executeController($controller_esp, $uriapp = NULL) {
        if (count($controller_esp['middlewares']) > 0) {
            if ($this->executeMiddlewares($controller_esp['middlewares']) === false) {
                return;
            }
        }
        
        $dir= $this->buildDir($controller_esp);
        $class= $this->buildClass($controller_esp);
        if(!class_exists($class)){
            //Si la clase no existe intento cargarla
            if(file_exists($dir)){
                require_once $dir;
            }else{
                //Avisa que el archivo no existe
                Error::general_error('Controller Error', 'The controller ' . $controller_esp['class'] . ' dont exists');
            } 
        }
        $controller= new $class();
        //Agrego los parametros URI
        $uri_params= UrlUri::uriParams($controller_esp['url'], $uriapp);
        $dinamic_method= $uri_params['dinamic'];
        $method= $uri_params['method']; 
        $parameters= $uri_params['params'] ? $uri_params['params'] : array();
        //Analizo si hay parametros en la configuracion
        if(isset($controller_esp['properties'])){
            $this->app->dependenciesEngine->injectProperties($controller, $controller_esp['properties']);
        }       
        //Saca el metodo HTPP y en base a eso hace una llamada al metodo correspondiente
        $methodHttp= filter_input(INPUT_SERVER, 'REQUEST_METHOD');
        if($dinamic_method){
            if($method != 'index' && !(method_exists($controller, $methodHttp . '_' . $method) || method_exists($controller, $method))){
                $parameters= array_merge(array('0' => $method), $parameters);
                $method= 'index';                
            }
            if(method_exists($controller, $methodHttp . '_' . $method)){
                $method= $methodHttp . '_' . $method;
            }
        }else if(isset($controller_esp['method'])){
            $method= $controller_esp['method'];
        }else{
            $method= "do" . ucfirst(strtolower($methodHttp));
        }
        $controller->setUriParams($parameters);
        if(method_exists($controller, $method)){
            $controller->$method($this->httpRequest, $this->httpResponse);
        }else{
            Error::general_error('HTTP Method Error', "The HTTP method $method is not supported");
        }
    }
1087499
protected function _getController()
    {
        $controller = parent::_getController();
        $cors = new CorsMiddleware();
        $controller->response = $cors(
            $controller->request, $controller->response,
            function($request, $response){ return $response; }
        );
        return $controller;
    }
1101066
def to_request
      item_pedido = {
        codigo_produto:           self.codigo_produto,
        codigo_categoria:         self.codigo_categoria,
        nome_produto:             self.nome_produto,
        quantidade_produto:       self.quantidade_produto,
        valor_unitario_produto:   self.valor_unitario_produto,
        nome_categoria:           self.nome_categoria,
      }
      return item_pedido
    end
241347
public function toProtobufRequest()
    {
        $request = new \POGOProtos\Networking\Requests\Request();
        $request->setRequestType($this->getType());

        if (($message = $this->getMessage()) !== null) {
            $request->setRequestMessage($message->toStream());
        }

        return $request;
    }
497070
protected function controllerMiddleware()
	{
		list( $class, $method ) = explode( '@', $this->action['uses'] );

		$controller = UniversalBuilder::resolve( $class );

		return ( new ControllerDispatcher( $this->router ) )->getMiddleware( $controller, $method );
	}
893307
private function createControllerFiles() {
        $moduleName = ucfirst($this->getModule());
        $moduleNameLower = strtolower($this->getModule());

        $controllerName = ucfirst($this->getController());
        $controllerNameLower = strtolower($this->getController());
        $controllerNameUpper = strtoupper($this->getController());

        /* Criação do arquivo de principal do controlador */
        $src_module_controller = file_get_contents($this->srcTemplateDirectory . 'Src_Module_Controller.tmpl');
        $srcModuleController = str_replace("%controllerNameUpper%", $controllerNameUpper, str_replace("%controllerNameLower%", $controllerNameLower, str_replace("%controllerName%", $controllerName, str_replace("%moduleName%", $moduleName, str_replace("%moduleNameLower%", $moduleNameLower, $src_module_controller)))));
        file_put_contents($this->dstControllerDirectory . ucfirst($this->getController()) . 'Controller.php', $srcModuleController);
        chmod($this->dstControllerDirectory . ucfirst($this->getController()) . 'Controller.php', 0644);

        /* Criação do arquivo de VIEW do controlador */
        file_put_contents($this->dstViewDirectory . 'index.phtml', '');
        chmod($this->dstViewDirectory . 'index.phtml', 0644);

        /* Criação do arquivo de TRANSLATE do controlador */
        file_put_contents($this->dstTranslateDirectory . 'index.php', "<?php\n\nreturn Array();");
        chmod($this->dstTranslateDirectory . 'index.php', 0644);
    }