Phalcon - Guida rapida

Phalcon viene introdotto come uno dei recenti framework di PHP, sviluppato da un gruppo di sviluppatori entusiasti. Phalcon è una struttura debolmente accoppiata, il che significa che consente ai suoi oggetti di essere trattati come componenti di colla, in base alle esigenze dell'applicazione.

Phalcon offre alcune caratteristiche uniche rispetto ad altri framework (tradizionali o esistenti) in PHP. Di seguito sono riportate alcune delle caratteristiche più importanti di Phalcon:

• È un framework open source full stack.

• Un utente ha bisogno di una quantità di codice molto inferiore per sfruttare diversi componenti.

• Può essere utilizzato per creare un framework indipendente come richiesto. Ad esempio, se abbiamo solo bisogno del componente Cache di Phalcon, possiamo usarlo in qualsiasi applicazione scritta in PHP puro o utilizzando un framework.

• Per uno sviluppatore che conosce Model-View-Controller (MVC) e Object- Relational Modeling (ORM), lavorare con Phalcon è come un gioco da ragazzi.

Prestazione

Le prestazioni di Phalcon sono una caratteristica che lo distingue da altri framework tradizionali di PHP. Phalcon ha una combinazione di PHP e C; ognuno di essi può essere utilizzato come modulo autonomo. La compilazione di ogni richiesta è considerata a una velocità più elevata in Phalcon, il che fa sembrare tutto fuori dagli schemi.

Linguaggio C.

Phalcon è compatibile con C che aumenta la velocità di compilazione. Inoltre, C in combinazione con Phalcon fornisce ORM (Object Relational Mapping) che fornisce coerenza con i modelli creati. Ogni modello creato in Phalcon è associato alla tabella del database relazionale. ORM in Phalcon è puramente implementato in C.

Strumenti di sviluppo

Gli strumenti per sviluppatori vengono utilizzati per lo sviluppo di applicazioni Web. Questi strumenti aiutano a generare un'applicazione di scaffold con una combinazione di tutte le funzioni (C - Crea, R - Leggi, U - Aggiorna, D - Elimina). Gli strumenti per sviluppatori includono anche il supporto estensibile per le librerie di terze parti da implementare in Phalcon.

Mappatura relazionale degli oggetti

Phalcon supporta un'ampia gamma di database. Non si limita all'accesso ai database relazionali. Supporta database sia relazionali che non relazionali, il che è come aggiungere una piuma al limite del framework Phalcon.

Phalcon Vs Other Framework

La tabella seguente evidenzia come Phalcon differisce da altri framework popolari come Yii e Laravel.

	Yii	Laravel	Phalcon
Tipo di progetti	Yii aiuta nella creazione di progetti su larga scala come forum, portali, CMS, servizi web RESTful, ecc.	Laravel viene utilizzato per la creazione di applicazioni web. È noto per la sintassi squisita e sofisticata.	Phalcon viene utilizzato per progettare una varietà di progetti.
Supporto database	Yii supporta tutti i database relazionali e non relazionali.	Laravel supporta tutti i database relazionali.	Phalcon fornisce lo stesso supporto ai database relazionali e non relazionali.
linguaggio	Il framework Yii è scritto esclusivamente in PHP.	Laravel è scritto in PHP e segue il pattern MVC.	Phalcon include sia PHP che C.
Scalabilità	Yii è abbastanza scalabile per progetti piccoli e medi.	La scalabilità è elevata per Laravel con tutti i tipi di progetti.	Ottimo per progetti medi.
Prestazione	Comparativamente basso.	Alto ma inferiore rispetto a Phalcon.	Alte prestazioni.

Prerequisites - Abbiamo bisogno dello stack WAMP / LAMP / MAMP o XAMPP per questo framework.

Di seguito sono riportati i passaggi per il processo di installazione del framework Phalcon in Windows.

Step 1 - L'installazione di Phalcon dipende completamente da dllfile. DLL (Dynamic Link Library) crea il pacchetto e i plugin richiesti per Phalcon.

Il seguente collegamento viene utilizzato per scaricare il file dll - https://phalconphp.com/en/download

Step 2- Scarica il file dll richiesto. Verificare la configurazione appropriata del sistema e scaricare il file dll richiesto. Dopo aver scaricato il file, estraiphalcon-php.dll per /php/ext nel xampp cartella.

Step 3 - Modifica il percorso in php.ini file per farlo configurare in modo simile ad altri .dll File.

Step 4 - Una volta modificato il percorso, riavviare il file xampp/wamppila. Sarà chiaramente visibile nel cruscotto, una volta che il filedll il file è impostato correttamente.

Step 5 - Dopo aver scaricato il pacchetto, impostare la variabile di percorso nelle proprietà di sistema.

Step 6 - Il dllI file e gli strumenti Phalcon insieme aiutano nella creazione del progetto / applicazione web. L'utente può verificare tramite il prompt dei comandi se il framework Phalcon è stato installato correttamente. L'output verrà visualizzato come mostrato nella seguente schermata.

Step 7 - Una volta ricevuto questo output necessario, creare un progetto utilizzando il seguente comando -

phalcon create-project <project-name>

Verrà visualizzato il seguente output.

Step 8- L'applicazione web è stata creata con successo. Fare clic sul seguente URL:http://localhost/demo1

L'output verrà visualizzato come mostrato nello screenshot seguente. È la pagina di benvenuto per Phalcon PHP.

In questo capitolo, discuteremo la struttura dell'applicazione di Phalcon. Di seguito è riportata la struttura completa delle directory di un progetto Phalcon.

C'è una cartella principale che è considerata come code baseed è pubblicamente disponibile per il server web. È anche chiamato comeweb directory. Altre cartelle al di fuori della directory principale web sono considerate fuori dalla portata del server web e del progetto Phalcon.

Una volta creato un progetto, la struttura della directory sarà visibile come segue nel file wamp/xamppcartella. Considera per il progetto che abbiamo creato nel capitolo precedente.

Di seguito sono riportate le cartelle e le sottocartelle del progetto.

App

Questa cartella è composta da tutti i file e le cartelle di script vitali. L'applicazione web completa è progettata sulla base della cartella “app”. I file di configurazione aiutano ad assistere la configurazione necessaria per eseguire l'applicazione senza problemi.

Di seguito è riportata la visualizzazione dettagliata della cartella dell'app per l'applicazione Web Phalcon specificata.

Consiste di configurazione, controller, libreria, migrazioni, modelli e visualizzazioni.

Config

Tutta la configurazione richiesta per l'applicazione web in Phalcon è contenuta in questa cartella. Comprende informazioni relative alla connettività del database, eventuali librerie di terze parti da aggiungere e i servizi da includere.

Controller

Tutti i controller sono inclusi in questa cartella. Sono utilizzati per elaborare le richieste e generare la risposta.

Biblioteca

Librerie di terze parti per l'applicazione web (a parte il framework Phalcon esistente).

Migrazioni

Questa sottocartella è composta da tutti i file associati alla migrazione dei dati, che possono essere utilizzati anche in qualsiasi altro framework.

Modelli

I modelli includono tutta la logica necessaria per interagire con il database. Viene effettivamente utilizzato per la rappresentazione dei dati.

Visualizzazioni

Costituisce tutte le viste relative all'applicazione web. Queste visualizzazioni vengono mostrate agli utenti finali con l'aiuto dei controller.

Cache

Questa directory include i dati relativi alla memorizzazione nella cache, che aiuta a migliorare le prestazioni.

Pubblico

Include tutte le cartelle per la gestione delle risorse che comprende CSS, JavaScript, file da caricare e alcuni metadati.

File .htaccess

Server Web in esecuzione su software Apache Web Server .htaccesscome file di configurazione. Quando viene inserito in una directory, tutta la configurazione necessaria viene caricata non appena viene avviato il server.

Ad esempio, è possibile configurare un sito Web in modo che sia disponibile solo per indirizzi IP specifici con .htaccess file.

Model View Controller (MVC)è un progetto software e un modello strutturale per lo sviluppo di applicazioni basate sul web. Questa architettura software separa la rappresentazione delle informazioni dall'interazione dell'utente con essa.

Il modello MVC definisce le applicazioni web con tre livelli logici.

Modello

I modelli sono oggetti che rappresentano la conoscenza. Dovrebbe esserci una relazione uno a uno tra il modello e le sue parti. Include tutta la logica da utilizzare per la connettività del database e l'esecuzione di operazioni CRUD.

Visualizza

Una vista è una rappresentazione visiva del suo modello. La vista interagisce con il modello o le sue parti e ottiene i dati necessari per la presentazione dal modello. Ciò si ottiene inviando richieste e ricevendo risposte appropriate. La visualizzazione include tutti i dati visualizzati dall'utente finale.

Controller

Un controller funge da intermediario tra l'utente e il sistema (modello e visualizzazione). Accetta la richiesta dell'utente, tramite la visualizzazione la invia al modello. Il modello lo manipola e invia la risposta al controller, che viene visualizzata come output all'utente finale tramite la visualizzazione.

Il controller riceve tale output utente e lo traduce nei messaggi appropriati. Questi messaggi vengono utilizzati dalla visualizzazione per visualizzare le risposte appropriate.

Flusso di lavoro in Phalcon

Il flusso di lavoro in Phalcon è il seguente:

• L'utente interagisce con l'interfaccia utente (view) e l'interazione viene mantenuta con l'aiuto di qualche metodo / evento.

• Questi metodi ed eventi vengono gestiti dal controller.

• Il controller accede al modello aggiornando l'azione dell'utente.

• View utilizza il modello per generare un output appropriato.

• La vista recupera i dati dal suo modello. Il modello non ha alcuna interazione diretta con la vista.

• L'interfaccia utente attende ulteriori interazioni con l'utente, che inizia con un nuovo ciclo di richiesta e risposta.

Phalcon include directory per Model, View e Controller. Lo screenshot seguente offre uno scenario migliore.

Tutta la logica aziendale è descritta nel controller e il modello interagisce con il database che include tutti i file rispetto a ciascuna tabella.

Note -

• Tutti i controller creati nell'applicazione web Phalcon si estendono Phalcon\Mvc\Controller.

• Tutti i modelli associati alle tabelle del database si estendono \Phalcon\Mvc\Model.

La cartella di configurazione dell'applicazione Web include i seguenti file:

• config.php
• loader.php
• services.php

config.php

Include le configurazioni per la connettività del database e il routing secondo il percorso della directory.

<?php 

/*
   * Modified: preppend directory path of current file, 
      because of this file own different ENV under between Apache and command line. 
   * NOTE: please remove this comment. 
*/ 

defined('BASE_PATH') || define('BASE_PATH', getenv('BASE_PATH') ?: 
   realpath(dirname(__FILE__) . '/../..')); 
defined('APP_PATH') || define('APP_PATH', BASE_PATH . '/app');  

return new \Phalcon\Config([ 
   'database' => [ 
      'adapter'     => 'Mysql', 
      'host'        => 'localhost', 
      'username'    => 'root', 
      'password'    => '', 
      'dbname'      => 'test', 
      'charset'     => 'utf8', 
   ], 
   'application' => [ 
      'appDir'         => APP_PATH . '/', 
      'controllersDir' => APP_PATH . '/controllers/', 
      'modelsDir'      => APP_PATH . '/models/', 
      'migrationsDir'  => APP_PATH . '/migrations/', 
      'viewsDir'       => APP_PATH . '/views/', 
      'pluginsDir'     => APP_PATH . '/plugins/', 
      'libraryDir'     => APP_PATH . '/library/', 
      'cacheDir'       => BASE_PATH . '/cache/', 
      'baseUri'        => '/demo1/', 
   ] 
]);

loader.php

Estende la classe esistente di \Phalcon\Loader(). La classe loader registra le directory che richiedono l'applicazione web.

<?php  
$loader = new \Phalcon\Loader();  

/** 
   * We're a registering a set of directories taken from the configuration file 
*/ 

$loader->registerDirs( [ 
      $config->application->controllersDir, 
      $config->application->modelsDir 
   ] 
)->register();

services.php

Questo file associa tutte le funzioni che implementano i servizi di un progetto web. ImplementaPhalcon\Diinterfaccia. Implementa anche un'iniezione di dipendenza dei servizi caricandoli.

Fondamentalmente, il file services.php all'interno della cartella config funge da contenitore di tutti i servizi. Questa interfaccia aiuta a inizializzare tutti i servizi come la connessione al database, l'impostazione dei cookie, la creazione di una nuova sessione o la connessione con il database NoSQL.

<?php  

use Phalcon\Mvc\View; 
use Phalcon\Mvc\View\Engine\Php as PhpEngine; 
use Phalcon\Mvc\Url as UrlResolver; 
use Phalcon\Mvc\View\Engine\Volt as VoltEngine; 
use Phalcon\Mvc\Model\Metadata\Memory as MetaDataAdapter; 
use Phalcon\Session\Adapter\Files as SessionAdapter; 
use Phalcon\Flash\Direct as Flash;   

/** 
   * Shared configuration service 
*/ 

$di->setShared('config', function () { 
   return include APP_PATH . "/config/config.php"; 
});  

/** 
   * The URL component is used to generate all kind of urls in the application 
*/ 

$di->setShared('url', function () { 
      $config = $this->getConfig(); 
      $url = new UrlResolver(); 
      $url->setBaseUri($config->application->baseUri);  
   return $url; 
});  

/** 
   * Setting up the view component 
*/ 
   
$di->setShared('view', function () { 
   $config = $this->getConfig();  
   $view = new View(); 
   $view->setDI($this); 
   $view->setViewsDir($config->application->viewsDir);  
   
   $view->registerEngines([ 
      '.volt' => function ($view) { 
         $config = $this->getConfig();  
         $volt = new VoltEngine($view, $this);  
         
         $volt->setOptions([ 
            'compiledPath' => $config->application->cacheDir, 
            'compiledSeparator' => '_' 
         ]);  
         return $volt; 
      }, 
      '.phtml' => PhpEngine::class  
   ]);  
   return $view; 
}); 

/** 
   * Database connection is created based in the parameters defined in the configuration 
      file 
*/ 

$di->setShared('db', function () { 
   $config = $this->getConfig();  
   $class = 'Phalcon\Db\Adapter\Pdo\\' . $config->database->adapter; 
   $connection = new $class([ 
      'host'     => $config->database->host, 
      'username' => $config->database->username, 
      'password' => $config->database->password, 
      'dbname'   => $config->database->dbname, 
      'charset'  => $config->database->charset 
   ]);  
   return $connection; 
});

Nel framework MVC, “C” sta per Controller che si riferisce ai centralini dell'applicazione web. Le azioni intraprese dal controller aiutano a passare i parametri alla vista in modo che possa visualizzare e rispondere di conseguenza all'input dell'utente.

Ad esempio, se ci registriamo tramite un modulo di registrazione che include dettagli dell'utente come nome utente, indirizzo e-mail e password e facciamo clic sul pulsante Invia, i dati inseriti o pubblicati dall'utente vengono inviati tramite il controller con l'aiuto di azione o funzione associata.

Caratteristiche di un controller

UN controller accetta input dalla vista e interagisce con il modello associato.

• Aiuta ad aggiornare lo stato del modello inviando comandi al modello. Può anche inviare comandi alla vista associata, il che aiuta a cambiare la presentazione della vista secondo lo stato del modello.

• Un controller funge da intermediario tra il modello e la vista.

Flusso di lavoro di un MVC in Phalcon

La figura seguente mostra il flusso di lavoro di MVC in Phalcon

Passaggi per creare un controller in Phalcon

Step 1- Reindirizza al percorso del progetto con l'aiuto del prompt dei comandi. Fare riferimento alla seguente schermata.

Come indicato nella schermata sopra, "demo" è il progetto associato al framework PHP Phalcon.

Step 2 - Utilizzare il comando seguente per creare un controller associato.

phalcon controller <controller-name>

Di seguito è riportato l'output in caso di corretta esecuzione del comando precedente.

Note- I nomi delle classi dei controller devono avere il suffisso "controller". Ciò implica una buona convenzione di denominazione seguita in Phalcon.

Per impostazione predefinita, quando l'applicazione viene creata nel framework PHP Phalcon, include un controller denominato "IndexController". Questo controller viene richiamato per impostazione predefinita per attivare le azioni.

Questo controller è esteso da controller-base a differenza di altri controller che si estende \Phalcon\Mvc\Controller.

Code -

<?php 
class IndexController extends ControllerBase { 
   public function indexAction() { 
      echo "This is my first web application in Phalcon"; 
   } 
}

Output -

Il modello nell'architettura MVC include la logica dell'applicazione. Il modello è l'interazione principale con il database. Dovrebbe essere in grado di gestire l'aggiornamento, l'eliminazione, l'inserimento e il recupero dei record secondo la richiesta dell'utente.

Per comprendere l'interazione del modello nel framework PHP Phalcon, è necessario seguire i seguenti passaggi.

Step 1 - Creazione di database.

Per ogni LAMP, WAMP, XAMPP stack software, è abbastanza facile creare un database con l'aiuto di phpmyadmin strumento di database.

Di seguito è riportata la query SQL per creare un database.

create database <database-name>

Step 2 - Nel phpmyadmin fare clic sulla scheda Database, menzionare il nome del database e fare ulteriormente clic sul pulsante Crea come mostrato nella seguente schermata.

Step 3 - Una volta che il database è stato creato con successo, creare una tabella che aiuterà la sua associazione per la creazione di un modello nel framework Phalcon.

Utilizzare la seguente query per creare una nuova tabella denominata "utenti".

DROP TABLE IF EXISTS `users`;  

CREATE TABLE `users` ( 
   `id` int(11) NOT NULL AUTO_INCREMENT, 
   `name` varchar(25), 
   `emailid` varchar(50), 
   `contactNumber` number 
   PRIMARY KEY (`id`) 
) 
ENGINE = InnoDB DEFAULT CHARSET = utf8;

Una volta che la tabella è stata creata, la sua struttura appare come quella mostrata nello screenshot seguente.

Step 4- Per creare un modello associato alla tabella "Utenti" che abbiamo creato nel passaggio precedente, apri l'istanza del prompt dei comandi. È importante reindirizzare al percorso del progetto appropriato. Prima di ciò, è fondamentale verificare se la configurazione del database è stata impostata correttamente come mostrato nello screenshot seguente.

Step 5 - Utilizzare il seguente comando per creare qualsiasi modello nel framework Phalcon.

phalcon model <model-name>

Di seguito è riportato l'output all'esecuzione del comando precedente.

Ciò implica che il modello è stato creato con successo.

Step 6- Il modello creato con successo è presente nella cartella dei modelli. Utilizzare il percorso seguente per visualizzare il punto in cui viene creato il modello.

C:\xampp\htdocs\demo1\app\models

Di seguito è riportato il codice completo per Users.php.

<?php  

class Users extends \Phalcon\Mvc\Model {
   /**      
      *      
      * @var integer 
      * @Primary 
      * @Identity
      * @Column(type = "integer", length = 11, nullable = false)      
   */      

   public $id; 
   /**
      *
      * @var string
      * @Column(type = "string", length = 25, nullable = true)      
   */ 

   public $name; 
   /**
      *
      * @var string
      * @Column(type = "string", length = 50, nullable = true)
   */      

   public $emailid; 
   /**
      *
      * @var integer
      * @Column(type = "integer", length = 11, nullable = true)
   */      

   public $contactNumber; 
   /**
      * Returns table name mapped in the model.
      *
      * @return string
   */      

   public function getSource() {
      return 'users';
   }  
   /**
      * Allows to query a set of records that match the specified conditions
      *
      * @param mixed $parameters
      * @return Users[]
   */ 

   public static function find($parameters = null) { 
      return parent::find($parameters);
   }  
   /**
      * Allows to query the first record that match the specified conditions
      *
      * @param mixed $parameters
      * @return Users
   */   
   
   public static function findFirst($parameters = null) {
      return parent::findFirst($parameters);
   } 
}

Step 7- Il Controller interagisce con il modello e la vista per ottenere l'output necessario. Come per il modello, utilizzare il seguente terminale di comando per creare un controller.

Phalcon controller <controller-name>

In caso di corretta esecuzione del comando precedente, il seguente è l'output.

Di seguito è riportato il codice per UserController.php.

<?php  

class UsersController extends \Phalcon\Mvc\Controller { 
   public function indexAction() { 
      echo "Users Controller has been called"; 
   } 
}

L'output verrà visualizzato se raggiungiamo il seguente URL: http://localhost/demo1/users

Le visualizzazioni sono informazioni presentate all'utente finale. Una visualizzazione può essere considerata come una pagina Web con la risposta appropriata da visualizzare. La risposta viene ricevuta tramite il controller che interagisce con il modello.

Nello specifico in Phalcon, la visualizzazione è composta da codice Volt, PHP e HTML. È disponibile una serie di delimitatori speciali per entrare in modalità Volt.{% ... %} viene utilizzato per eseguire istruzioni come cicli for o assegnare valori e {{ ... }} stampa il risultato di un'espressione nel modello.

Le viste in Phalcon sono fondamentalmente classificate in due tipi:

• Volt
• phtml

Volt

Di seguito è riportato lo screenshot dell'output che avevamo creato per il progetto demo1 nel capitolo precedente.

Questo output si ottiene con l'aiuto di file views/index/index.volt.

Caratteristiche dei file Volt

• È un modello scritto in linguaggio C ed è notevolmente veloce rispetto ad altri linguaggi.

• Include una serie di componenti altamente integrati, che sono molto vantaggiosi in Phalcon.

• Può anche essere utilizzato come componente autonomo.

• Volt è compilato in puro codice PHP.

Di seguito è riportato il codice per index.volt che carica di default per qualsiasi progetto.

<!--<div class = "page-header"> 
   <h1>Congratulations!</h1> 
</div>--> 

<p>This is my first web application in Phalcon </p> 
<!--<p>You're now flying with Phalcon. Great things are about to happen!</p>

<p>This page is located at <code>views/index/index.volt</code></p>-->

Rendering gerarchico

Le viste in Phalcon supportano il rendering gerarchico e Phalcon\Mvc\Viewviene utilizzato come componente di rendering predefinito. Questo componente utilizza PHP come motore di modelli rispetto ai file volt che utilizzano C come linguaggio di modelli.

Queste visualizzazioni dovrebbero avere .phtmlestensione. La directory predefinita delle viste per il progetto dato è composta dai seguenti tre file:

• Action view- Questa vista è chiamata per eseguire una particolare azione. Viene chiamato quando viene eseguita l'azione "mostra".

• Controller layout- Questa vista è presente all'interno della cartella dei layout. Per esempio,C:\xampp\htdocs\demo\app\views\layouts. Richiama le chiamate al metodo associate al controller appropriato. Il codice implementato nel layout verrà implementato come e quando richiesto.

• Main layout - Questa visualizzazione del layout richiamerà l'azione principale e verrà mostrata per ogni controller o azione all'interno dell'applicazione web.

Differenza tra file .volt e .phtml

.volt	.phtml
L'estensione .volt viene utilizzata quando il motore del modello impostato nell'applicazione è scritto in C	.phtml viene utilizzato quando il motore del modello è PHP stesso
Può essere utilizzato come componente autonomo	Non può essere utilizzato come componente autonomo
Le visualizzazioni Volt sono compilate in codice PHP	Il file phtml stesso include il codice PHP, quindi non è necessaria la compilazione nel framework Phalcon

Variabili

Le variabili vengono assegnate e modificate nel modello utilizzando "set".

Dichiarazione di un array

{% set fruits = ['Apple', 'Banana', 'Orange'] %}

Dichiarare una stringa

{% set name = ”John Kennedy” %}

Commenti

I commenti possono anche essere aggiunti a un modello utilizzando il {# ... #}Delimitatori. Tutto il testo al loro interno viene semplicemente ignorato nell'output finale.

{# note: this is a comment 
   {% set price = 100; %} 
#}

Esempio

{% set fruits = ['Apple', 'Banana', 'Orange'] %} 

<h1>Fruits</h1> 

<ul> 
   {% for fruit in fruits %} 
   <li>{{ fruit|e }}</li> 
   {% endfor %} 
</ul>  

{% set robots = ['Voltron', 'Astro Boy', 'Terminator', 'C3PO'] %}  

<ul> 
   {% for robot in robots %} 
   <li>{{ robot }}</li> 
   {% endfor %} 
</ul>

Produzione

Il codice produrrà la seguente schermata di output:

Il componente router consente di definire rotte che vengono mappate ai controller o gestori che dovrebbero ricevere la richiesta. Un router analizza un URI in base alle informazioni ricevute.

Ogni router nell'applicazione web ha due modalità:

• Modalità MVC
• Modalità solo match

La prima modalità è ideale per lavorare con le applicazioni MVC. La seguente è la sintassi per definire un percorso in Phalcon.

$router = new Router();  

// Define a route 

$router->add( 
   "<URI-Name>", 
   [ 
      "controller" => "<controller-name>", 
      "action"     => "<action-name>", 
   ] 
);

Esempio

Per cercare una categoria, creiamo un percorso in routes.php della cartella di configurazione.

Considera la creazione di una rotta che chiamerà un metodo di accesso mentre invochiamo “UsersController”. In tal caso, si suggerisce di creare un percorso che mappa l'URL specificato.

<?php  

$router = new Phalcon\Mvc\Router();  

$router->add('/login', array( 
   'controller' => 'users', 
   'action' => 'login', 
));
  
return $router;

Produzione

Il codice produrrà il seguente output:

In questo capitolo, discuteremo la connettività del database relativa a Phalcon.

Creazione di database e design

Ci concentreremo sulla creazione di un database per i blog che mantiene i post insieme alle categorie secondo le voci degli utenti.

Nome database: blog-tutorial

Query utilizzata per creare il database -

drop database blog-tutorial (if exists) 
create database blog-tutorial

Dopo la creazione del database, il database verrà elencato come mostrato nella seguente schermata.

Phalcon utilizza i comandi per la creazione di models, controllerse persino progetti. Vediamo come funziona.

Step 1 - Crea un progetto denominato blog-tutorial.

Step 2 - Configurare l'applicazione web che si connette al database che abbiamo creato per la gestione dei blog.

<?php  
return new \Phalcon\Config (array ( 
   'database' => array ( 
      'adapter'  => 'Mysql', 
      'host'     => 'localhost', 
      'username' => 'root', 
      // 'dbname'   => 'blog_tutorial', 
      'password' => '', 
      'name'     => 'blog_tutorial', 
   ), 
   'application' => array ( 
      'controllersDir' => __DIR__ . '/../../app/controllers/', 
      'modelsDir'      => __DIR__ . '/../../app/models/', 
      'viewsDir'       => __DIR__ . '/../../app/views/', 
      'baseUri'        => '/blog-tutorial/', 
   ) 
));

Abbiamo utilizzato un database MySQL nella nostra applicazione. Se volessimo cambiare il software del database a metà flusso, non sarebbe troppo difficile, a patto che avessimo la stessa struttura dati nel nostro nuovo database.

PostgreSQL

Configura l'applicazione web che si connetterà al database PostgreSQL.

Ciò può essere ottenuto utilizzando il codice seguente. I servizi includerannoPhalcon\Db\Adapter\Pdo\Postgresql

use Phalcon\Db\Adapter\Pdo\Postgresql;  

$config = [ 
   'host'     => 'localhost', 
   'dbname'   => 'blog_tutorial', 
   'port'     => 5432, 
   'username' => 'root', 
   'password' => '' 
];  

$connection = new Postgresql($config);

SQLite

Per implementare la connessione SQLite, la configurazione dovrebbe essere estesa con Phalcon\Db\Adapter\Pdo\Sqlite classe astratta.

<?php  
 
use Phalcon\Db\Adapter\Pdo\Sqlite;  

$connection = new Sqlite(['dbname' => '/tmp/blog_tutorial.sqlite']);

Oracolo

Per implementare la connessione al database Oracle in Phalcon, la configurazione dovrebbe essere estesa con Phalcon\Db\Adapter\Pdo\Oracle classe astratta.

<?php  

use Phalcon\Db\Adapter\Pdo\Oracle;  

$config = array ( 
   "dbname" => "//localhost/blog_tutorial", 
   "username" => "root", 
   "password" => "" 
); 

$connection = new Phalcon\Db\Adapter\Pdo\Oracle($config);

Lo scaffolding di solito si riferisce a un tipo di generazione di codice in cui lo indirizziamo a un database di applicazioni Web, il che si traduce nella creazione di un'applicazione CRUD (Crea, Leggi, Aggiorna, Elimina) di base.

Prima di progettare un'applicazione CRUD, è importante progettare le tabelle del database in base alle necessità dell'applicazione.

Step 1 - Creare un'applicazione di scaffolding che includerà tutte le operazioni crud.

Command: phalcon scaffold <table-name>

Il generatore di scaffold di Phalcon una volta eseguito creerà file e cartelle descritti nella tabella seguente.

Step 2 - Crea una pagina indice (combinazione di phtml e volt).

Codice da includere in index.phtml nella cartella degli utenti.

<?php use Phalcon\Tag as Tag ?> 
<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <title>Blog Tutorial</title> 
      <link rel = "stylesheet" type = "text/css" 
         href = "http://netdna.bootstrapcdn.com/twitter-bootstrap/2.2.1/css/bootstrapcombined.min.css"/> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1.0"> 
   </head> 
   
   <body>  
      <div class = "navbar navbar-fixed-top"> 
         <div class = "navbar-inner"> 
            <div class = "container"> 
               <a class = "btn btn-navbar" data-toggle = "collapse" datatarget = ".nav-collapse"> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
               </a> 
               <a class = "brand" href = "#">Blog Collection</a> 
               
               <div class = "nav-collapse"> 
                  <ul class = "nav pull-left"> 
                     <li> 
                        <?php echo Phalcon\Tag::linkTo('index', 'Home Page') ?> 
                     </li> 
                     
                     <?php if ($this->session->has('auth')) { ?> 
                        <li> 
                           <?php echo Phalcon\Tag::linkTo('posts/index', '+Posts') ?> 
                        </li> 
                     
                        <li> 
                           <?php echo Phalcon\Tag::linkTo('categories/index', '+Categories') ?> 
                        </li> 
                     
                        <li> 
                           <?php echo Phalcon\Tag::linkTo('users/logout', 'Log out') ?> 
                        </li> 
                     <?php } else { ?> 
                        <li> 
                           <?php echo Phalcon\Tag::linkTo('users/index', 'Log in') ?> 
                        </li> 
                     <?php } ?> 
                  </ul> 
               </div> 
               
            </div> 
         </div>  
      </div>
      <?php echo $this->getContent() ?>  
      
      <script src = "http://netdna.bootstrapcdn.com/twitterbootstrap/2.2.1/js/bootstrap.min.js"></script> 
   </body> 
</html>

File predefinito index.volt includerà il codice seguente.

<?php echo $this->getContent() ?>  

<div align = "center">  
   <h1>Welcome!</h1>  
   <p>Welcome to the blog collection of Phalcon</p>  
</div>

L'esecuzione corretta del codice precedente produce il seguente output.

Step 3 - Cambia con i rispettivi modelli.

Users.php

<?php  

class Users extends \Phalcon\Mvc\Model {  
   /** 
      * @var integer 
      * 
   */ 
   
   public $id;  
   /** 
      * @var string 
      * 
   */ 
    
   public $login;  
   /** 
      * @var string 
      * 
   */ 
   
   public $password; 
   /** 
      * Initializer method for model. 
   */ 
    
   public function initialize() { 
      $this->hasMany("id", "Posts", "users_id"); 
   } 
}

La funzione denominata ‘initialize’ aiuta a implementare la relazione tra id e users_id nella tabella Posts, il che significa che ogni utente unico ha molti post associati nella tabella.

Posts.php

<?php  

class Posts extends \Phalcon\Mvc\Model {  
   /** 
      * @var integer 
      * 
   */ 
   
   public $id;  
   /** 
      * @var string 
      * 
   */ 
    
   public $title;  
   /** 
      * @var string 
      * 
   */ 
   
   public $slug;  
   /** 
      * @var string 
      * 
   */ 
   
   public $content;  
   /** 
      * @var string 
      * 
   */ 
   
   public $created; 
   /** 
      * @var integer 
      * 
   */ 
   
   public $users_id;  
   /** 
      * @var integer 
      * 
   */ 
    
   public $categories_id;   
   /** 
      * Initializer method for model. 
      */ 
   
   public function initialize() { 
      $this->belongsTo("users_id", "Users", "id"); 
      $this->belongsTo("categories_id", "Categories", "id"); 
   } 
}

La funzione ‘initialize’ include il vincolo di relazione che menziona la chiave esterna e la relazione della chiave primaria con la tabella.

users_id si riferisce all'id nella tabella "Utenti".

categories_id si riferisce all'id nella tabella "Categorie".

Categories.php

<?php  

class Categories extends \Phalcon\Mvc\Model {  
   /** 
      * @var integer 
      * 
   */ 

   public $id;  
   /** 
      * @var string 
      * 
   */ 

   public $name;  
   /** 
      * @var string 
      * 
   */ 

   public $slug;   
   /** 
      * Initializer method for model. 
   */ 
   
   public function initialize() { 
      $this->hasMany("id", "Posts", "categories_id"); 
   } 
}

Simile al modello Users, il ‘initialize’ funzione specifica che ne include molti categories_id per il post dato.

Progettazione della pagina di accesso

Creazione di viste

Di seguito è riportata la struttura completa del progetto Blog-tutorial-master.

La vista associata per la visualizzazione della home page dopo che l'utente ha effettuato correttamente l'accesso è “index.phtml”.

<?php use Phalcon\Tag as Tag ?> 
<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <title>Blog Tutorial</title> 
      <link rel = "stylesheet" type = "text/css" href = "http://netdna.bootstrapcdn.com/twitter-bootstrap/2.2.1/css/bootstrapcombined.min.css"/> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1.0"> 
   </head> 

   <body>  
      <div class = "navbar navbar-fixed-top"> 
         <div class = "navbar-inner"> 
            <div class = "container"> 
               <a class = "btn btn-navbar" data-toggle = "collapse" datatarget = ".nav-collapse"> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
               </a> 
               <a class = "brand" href = "#">Blog Collection</a> 
               
               <div class = "nav-collapse"> 
                  <ul class = "nav pull-left"> 
                     <li> 
                        <?php echo Phalcon\Tag::linkTo('index', 'Home Page') ?> 
                     </li> 
                     <?php if ($this->session->has('auth')) { ?> 
                        <li> 
                           <?php echo Phalcon\Tag::linkTo('posts/index', '+Posts') ?> 
                        </li> 
                        
                        <li> 
                           <?php echo Phalcon\Tag::linkTo('categories/index', '+Categories') ?> 
                        </li> 
                        
                        <li> 
                           <?php echo Phalcon\Tag::linkTo('users/logout', 'Log out') ?> 
                        </li> 
                     <?php } else { ?> 
                        <li>
                           <?php echo Phalcon\Tag::linkTo('users/index', 'Log in') ?> 
                        </li> 
                     <?php } ?> 
                  </ul> 
               </div>
               
            </div> 
         </div>
      </div>            
      <?php echo $this->getContent() ?>  
      <script src = "http://netdna.bootstrapcdn.com/twitterbootstrap/2.2.1/js/bootstrap.min.js"></script> 
   </body> 
</html>

Gestione delle categorie

Phalcon Query Language (PHQL) chiamato anche come PhalconQL è un dialetto SQL di alto livello che standardizza le query SQL per i sistemi di database supportati da Phalcon.

Include un parser, scritto in C, che traduce la sintassi in RDBMS di destinazione.

Ecco un elenco di alcune delle caratteristiche principali del linguaggio di query Phalcon:

• Per la sicurezza dell'applicazione web, utilizza parametri associati.

• Le tabelle vengono trattate come modelli mentre le colonne vengono trattate come attributi di classe.

• Tutte le istruzioni di manipolazione dei dati vengono utilizzate per prevenire la perdita di dati che può verificarsi.

• L'iniezione di SQL viene impedita mantenendo una chiamata di query SQL alla volta.

Creazione di una query PHQL

Le query vengono create istanziando la classe Phalcon\Mvc\Model\Query.

Esempio

// Instantiate the Query 
$query = new Query( 
   "SELECT * FROM Users", 
   $this->getDI() 
);  

// Execute the query returning a result if any 
$cars = $query->execute();

Nei capitoli precedenti, abbiamo visto il funzionamento dell'applicazione web scaffold denominata blog tutorial. Comprendeva la ricerca di categorie secondo il nome o lo slug.

Di seguito è riportato il codice incluso per searchAction.

public function searchAction() {  
   $numberPage = 1; 
   if ($this->request->isPost()) { 
      $query = Criteria::fromInput($this->di, "Categories", $_POST); 
      $this->session->conditions = $query->getConditions(); 
   } else { 
      $numberPage = $this->request->getQuery("page", "int"); 
      if ($numberPage <= 0) { 
         $numberPage = 1; 
      } 
   } 
   
   $parameters = array(); 
   if ($this->session->conditions) { 
      $parameters["conditions"] = $this->session->conditions; 
   } 
   
   // $parameters["order"] = "id"; 
   $categories = Categories::find($parameters); 
   if (count($categories) == 0) { 
      $this->flash->notice("The search did not find any categories"); 
      
      return $this->dispatcher->forward(array( 
         "controller" => "categories", 
         "action" => "index" 
      )); 
   } 
   
   $paginator = new \Phalcon\Paginator\Adapter\Model(array( 
      "data" => $categories, 
      "limit"=> 10, 
      "page" => $numberPage 
   )); 
   
   $page = $paginator->getPaginate(); 
   $this->view->setVar("page", $page); 
}

La query PHQL eseguita (evidenziata) nel controller recupererà tutti i risultati secondo la condizione di ricerca. Il risultato di qualsiasi query di ricerca in base alle condizioni verrà visualizzato come nello screenshot.

Di seguito è riportato l'output ricevuto in caso di corretta esecuzione del codice precedente.

Ciclo di vita di PHQL

Essendo un linguaggio di alto livello, PHQL offre la possibilità agli sviluppatori di personalizzare e personalizzare vari aspetti secondo i requisiti.

Di seguito è riportato il ciclo di vita di ogni istruzione PHQL eseguita in Phalcon:

• Ogni istruzione PHQL viene analizzata e convertita come una rappresentazione intermedia (IR) che è completamente indipendente dall'SQL implementato dal sistema di database.

• L'IR viene convertito in un'istruzione SQL secondo il sistema di database utilizzato nell'applicazione web. Le istruzioni SQL generate sono associate al modello.

• Tutte le istruzioni PHQL vengono analizzate una volta e memorizzate nella cache. Se viene eseguito lo stesso risultato dell'istruzione, sarà utile per prestazioni più veloci.

La migrazione del database è importante per i seguenti motivi:

• La migrazione del database aiuta a trasferire i dati tra i tipi di archiviazione specificati.

• La migrazione del database si riferisce al contesto delle applicazioni basate sul Web che migrano da una piattaforma all'altra.

• Questo processo di solito ha luogo per tenere traccia dei dati che sono obsoleti.

Phalcon esegue il processo di migrazione del database nel modo seguente:

Step 1 - Crea un progetto denominato “dbProject” in xampp/wamp directory.

Step 2 - Configurare il progetto con la connettività database appropriata.

<?php 

/*  
   * Modified: preppend directory path of current file, 
      because of this file own different ENV under between Apache and command line.  
   * NOTE: please remove this comment.  
*/

defined('BASE_PATH') || define('BASE_PATH', getenv('BASE_PATH') ?: realpath(dirname(__FILE__) . '/../..')); 
defined('APP_PATH') || define('APP_PATH', BASE_PATH . '/app');  
return new \Phalcon\Config(['database' => [
   'adapter' => 'Mysql', 
   'host' => 'localhost', 
   'username' => 'root', 
   'password' => '', 
   'dbname' => 'demodb', 
   'charset' => 'utf8', ],

'application' => [ 'appDir' => APP_PATH . '/', 
   'controllersDir' => APP_PATH . 
   '/controllers/', 'modelsDir' => APP_PATH . 
   '/models/', 'migrationsDir' => APP_PATH . 
   '/migrations/', 'viewsDir' => APP_PATH . 
   '/views/','pluginsDir' => APP_PATH . 
   '/plugins/', 'libraryDir' => APP_PATH . 
   '/library/', 'cacheDir' => BASE_PATH . 
   '/cache/', 'baseUri' => '/dbProject/', 
] ]);

Step 3- Eseguire il comando per la migrazione delle tabelle incluse all'interno del database “demodb”. Per ora, include una tabella "utenti".

Step 4 - I file di database migrati vengono archiviati nella directory delle migrazioni all'interno della cartella "app".

Pertanto, le tabelle vengono migrate correttamente.

Comprensione dell'anatomia dei file migrati

Il file migrato ha una classe unica che si estende Phalcon\Mvc\Model\Migrationclasse. La classe Migration in Phalcon include i metodiup() e down(). Ilup() viene utilizzato per eseguire la migrazione mentre il metodo down ripristina l'operazione.

Users.php

<?php  

use Phalcon\Db\Column; 
use Phalcon\Db\Index; 
use Phalcon\Db\Reference; 
use Phalcon\Mvc\Model\Migration;  

/**  
   * Class UserMigration_100  
*/ 

class UserMigration_100 extends Migration {     
   /**      
      * Define the table structure      
      *      
      * @return void 
   */      
   public function morph() { 
      $this->morphTable('user', [ 
         'columns' => [ 
            new Column( 'Id', [ 
               'type' => Column::TYPE_INTEGER, 
               'notNull' => true, 
               'autoIncrement' => true, 
               'size' => 11, 'first' => true ] ), 
            new Column( 'username', [ 
               'type' => Column::TYPE_VARCHAR, 
               'notNull' => true, 
               'size' => 40, 
               'after' => 'Id' ] ), 
            new Column( 'email', [ 
               'type' => Column::TYPE_VARCHAR, 
               'notNull' => true, 
               'size' => 40, 
               'after' => 'username' ] ), 
            new Column( 'password', [ 
               'type' => Column::TYPE_VARCHAR, 
               'notNull' => true, 
               'size' => 10, 
               'after' => 'email' ] ) 
         ],  
         'indexes' => [new Index('PRIMARY', ['Id'], 'PRIMARY') ], 
            'options' => [ 'TABLE_TYPE' => 'BASE TABLE', 
               'AUTO_INCREMENT' => '3', 'ENGINE' => 'InnoDB', 
               'TABLE_COLLATION' => 'latin1_swedish_ci' ], 
      ] ); 
   }  
   
   /**      
      * Run the migrations      
      *      * @return void      
   */     

   public function up() {  
   }  

   /**      
      * Reverse the migrations      
      *
      * @return void      
   */
   public function down() {  
   } 
}

La classe UserMigration_100 come mostrato nell'esempio sopra include un array associativo con quattro sezioni che sono:

• Columns - Include una serie di colonne della tabella.

• Indexes - Include una serie di indici di tabella.

• References - Include tutti i vincoli di integrità referenziale (chiave esterna).

• Options - Array con una serie di opzioni per la creazione di tabelle.

Come mostrato nell'esempio precedente, la versione 1.0.0 del database è stata migrata correttamente. Phalcon può includere ed eseguire più processi di migrazione a seconda di come viene conservato il contenuto del database.

Cookie noti anche come browser cookiessono piccoli file di testo memorizzati nel browser. Salva tutte le informazioni relative all'identità dell'utente. Queste informazioni vengono utilizzate per convalidare gli utenti una volta che esplorano pagine diverse.

Esistono due diversi tipi di cookie:

• Session Cookies- Questi tipi di cookie rimangono nel browser e conservano le informazioni fino alla chiusura del browser. Non appena il browser viene aperto, verrà considerato come una nuova sessione per lo stesso utente.

• Persistent Cookies- Include una durata di vita stabilita e rimane nel browser entro la durata di vita specificata. Quei siti web che utilizzano cookie persistenti tengono traccia di ogni utente, anche se il browser viene chiuso dall'utente.

Parliamo ora di come funzionano i cookie in Phalcon.

Biscotti in Phalcon

Phalcon utilizza Phalcon\Http\Response\Cookiescome archivio globale per i cookie. I cookie vengono memorizzati in Phalcon durante l'invio di una richiesta al server.

Di seguito è riportata la sintassi per impostare un cookie:

$this->cookies->set( 
   "<cookie-name>", 
   "<cookie-value>", 
   time 
);

Considera il seguente esempio. Utilizzando il seguente codice, creeremo cookie dell'utente quando l'utente accede all'applicazione web.

<?php  

class UsersController extends \Phalcon\Mvc\Controller { 
   public function indexAction() { 
      if ($this->cookies->has("login-action")) { 
         // Get the cookie 
         $loginCookie = $this->cookies->get("login-action"); 
         
         // Get the cookie's value 
         $value = $loginCookie->getValue(); 
         echo($value); 
      } 
      $this->cookies->set( 
         "login-action", 
         "abc", 
         time() + 15 * 86400 
      ); 
   } 
}

I cookie crittografati verranno visualizzati come output.

Descrizione

Cookie denominato “loginAction” è stato creato con valore “abc”.

Il metodo “indexAction” controlla se il cookie esiste e stampa il valore di conseguenza.

Crittografia dei cookie

I cookie in Phalcon vengono crittografati prima di essere inviati al server come richiesta e decrittografati non appena otteniamo una risposta appropriata dal server. Ciò garantisce la sicurezza degli utenti autorizzati.

Si suggerisce sempre di evitare di memorizzare dati sensibili nei cookie, nonostante le funzionalità di crittografia e decrittografia. La configurazione per la crittografia dei cookie è inclusa inservices.php file.

/** 
   * Enable encryption key for setting values of cookies 
*/  

$di->set( 
   "cookies", function () { 
      $cookies = new Cookies();  
      $cookies->useEncryption(false);  
      return $cookies; 
   } 
); 

/** 
   * Set encryption key 
*/ 

$di->set( 
   "crypt", function () { 
      $crypt = new Crypt(); 
      $crypt->setKey('[email protected]!sft56$'); // Use a unique Key!  
      return $crypt; 
   } 
);

Note -

• Si consiglia sempre di utilizzare la crittografia durante l'invio di cookie al server.

• Se la crittografia non viene utilizzata, tutta l'applicazione interna verrà esposta all'attaccante.

• Si consiglia inoltre di memorizzare piccoli dati e valori letterali nei cookie.

Le sessioni sono l'archiviazione di informazioni lato server che aiuta nell'interazione dell'utente con il sito web o l'applicazione web. Ogni sessione è definita in modo univoco con un ID di sessione, che viene passato al server Web ogni volta che il browser effettua una richiesta HTTP. L'ID di sessione viene associato ogni volta al database interno in modo che tutte le variabili memorizzate vengano recuperate.

Sessioni a Phalcon

Phalcon utilizza componenti di sessione che includono i wrapper per accedere ai dati della sessione.

Di seguito sono riportate le funzionalità di Phalcon:

• I dati della sessione possono essere isolati da altri componenti sullo stesso dominio.

• In base alle esigenze dell'applicazione, il valore della sessione può essere modificato con l'aiuto dell'adattatore di sessione.

Avvio di una sessione in Phalcon

Tutte le attività di sessione sono associate ai file dell'adattatore dichiarati in Services.php file all'interno del /config cartella dell'applicazione web.

/** 
   * Start the session the first time some component requests the session service 
*/ 
$di->setShared('session', function () { 
   $session = new SessionAdapter(); 
   $session->start();  
   return $session; 
});

Creazione di una sessione

Step 1 - Creare un controller di sessione per creare un'istanza di una sessione in modo che i dati possano essere recuperati in modo appropriato.

Step 2 - Crea una sessione con un nome e un valore.

<?php  

class SessionController extends \Phalcon\Mvc\Controller { 
   public function indexAction() { 
      //Define a session variable 
      $this->session->set("user-name", "Omkar"); 
      
      //Check if the variable is defined 
      if ($this->session->has("user-name")) { 
         //Retrieve its value 
         $name = $this->session->get("user-name"); 
         echo($name); 
      } 
   } 
}

Il codice precedente produce il seguente output.

Rimozione di una sessione

È possibile distruggere la sessione o annullare l'impostazione di alcuni valori variabili all'interno della sessione in Phalcon.

Di seguito è riportata la sintassi per annullare l'impostazione dei valori delle variabili nella sessione.

$this->session->remove(<variable-name>);

Come mostrato nell'esempio sopra, il nome della variabile creata nella sessione è “data-content” che può essere rimosso utilizzando il codice seguente.

public function removeAction() { 
   // Remove a session variable with associated session 
   $this->session->remove("data-content"); 
}

Di seguito è riportata la sintassi per distruggere l'intera sessione.

$this->session->destroy();

Phalcon include un componente Phalcon\Translate che fornisce supporto multilingue ed è molto utile per creare pagine web, che vengono tradotte in più lingue.

Include un adattatore che aiuta a legare gli array e aiuta a leggere i messaggi di traduzione.

Esempio

Creiamo un output con l'aiuto del componente Translate in Phalcon, che ci aiuterà a visualizzare l'output secondo la lingua suggerita.

Step 1- Phalcon dà la libertà a ogni sviluppatore di organizzare le stringhe di traduzione. Considera l'idea di conservare due file diversi, ovvero:en.php (per archi inglesi) e fr.php (per archi francesi).

Il file conterrà un array di coppie chiave-valore, in cui le chiavi sono univoche e i valori differiranno a seconda della traduzione necessaria.

en.php

<?php  

// app/messages/en.php 

$messagesContent = [ 
   "bye"     => "Good Bye", 
   "hi-name" => "Hello %name%", 
   "song"    => "Your favorite song is %song%", 
];

fr.php

<?php 

// app/messages/fr.php 

$messagesContent = [ 
   "bye"        => "Au revoir", 
   "hello-name" => "Bonjour %name%", 
   "song"       => "Votre chanson préférée est %song%", 
];

Step 2 - In un'applicazione, crea un file UserController che prenderà i parametri su quale file dovrebbe essere usato per la traduzione.

<?php 

use Phalcon\Translate\Adapter\NativeArray; 

class UserController extends \Phalcon\Mvc\Controller {  
   protected function getMessageTransalation() { 
      // Ask for the best language 
      // Display the output in desired language 
      require "en.php";   
      
      // Return a translation object 
      return new NativeArray( ["content" => $messagesContent,]); 
   }  
   public function indexAction() { 
      $this->view->name = "Radhika"; 
      $this->view->song= "Ton sourire m'ensorcelle Je suis fou de toi Le désir coule dans mes veines Guidé par ta voix"; 
      $this->view->t    = $this->getMessageTransalation(); 
   } 
}

Per il metodo predefinito, vengono presi due parametri, il primo è il nome e il secondo è la canzone preferita dell'utente. Successivamente, la funzionegetMessageTranslation viene chiamato che restituisce l'output desiderato.

Per ora, vogliamo l'output in inglese.

Step 3 - L'associato code view demo\app\views\User\index.volt includerà il seguente codice:

<p><?php echo $t->_("hello-name", ["name" => $name]); ?></p> 
<p><?php echo $t->_("song", ["song" => $song]); ?></p>

Se vogliamo che l'output completo venga visualizzato in francese, dobbiamo solo cambiare il nome del file.

require "fr.php";

Di seguito è riportato l'output in francese.

Le risorse riguardano i componenti aggiuntivi oltre al framework esistente in Phalcon. Phalcon ha un asset manager che aiuta a gestire tutti i componenti degli asset come i file CSS o JS.

I metodi comuni utilizzati sono:

Metodo	Importanza
__construct (variabile $ opzioni)	Inizializza il componente Phalcon \ Assets \ Manager
addCss (stringa $ percorso, variabile $ locale, variabile $ filtro, variabile $ attributi)	Aggiunge una risorsa CSS dalla raccolta "css" a una vista particolare
addJs (stringa $ percorso, variabile $ locale, variabile $ filtro, variabile $ attributi)	Aggiunge una risorsa JavaScript alla raccolta "js"

Esempio

Considera il progetto di esempio di Phalcon “vokuro” che è l'illustrazione migliore per l'aggiunta cssFile. Includerà asset / Manager per richiamare tutti i filecss File.

Il controller predefinito per il progetto richiamerà tutti i file css File.

<?php 

namespace Vokuro\Controllers; 
use Phalcon\Assets\Manager;  

/** 
   * Display the default index page. 
*/ 

class IndexController extends ControllerBase {  
   /** 
      * Default action. Set the public layout (layouts/public.volt) 
   */ 
   public function indexAction() { 
      $this->assets->addCss("public/style.css"); 
      $this->view->setVar('logged_in', is_array($this->auth->getIdentity())); 
      $this->view->setTemplateBefore('public'); 
   } 
}

Style.css

div.remember { 
   margin-top: 7px; 
   color: #969696; 
}  
div.remember label { 
   padding-top: 15px; 
}  
div.forgot { 
   margin-top: 7px; 
   color: #dadada; 
}  
footer { 
   background: url("../img/feature-gradient.png") no-repeat scroll center 100% white; 
   color: #B7B7B7; 
   font-size: 12px; 
   padding: 30px 0; 
   text-align: center; 
}  
footer a { 
   margin-left: 10px; 
   margin-right: 10px; 
}  
table.signup td { 
   padding: 10px; 
}  
table.signup .alert { 
   margin-bottom: 0; 
   margin-top: 3px; 
}  
table.perms select { 
   margin-top: 5px; 
   margin-right: 10px; 
}  
table.perms label { 
   margin-right: 10px; 
}  
div.main-container { 
   min-height: 450px; 
}

Le risorse saranno gestite all'interno delle viste, che mostreranno i file CSS come output.

Index.volt

{{ content() }} 
{{ assets.outputCss() }} 

<header class = "jumbotron subhead" id = "overview"> 
   <div class = "hero-unit"> 
      <h1>Welcome!</h1> 
      <p class = "lead">This is a website secured by Phalcon Framework</p> 
      <div align = "right"> 
         {{ link_to('session/signup', '<i class="icon-ok icon-white">
            </i> Create an Account', 'class': 'btn btn-primary btn-large') }} 
      </div> 
   </div> 
</header>

Produzione

Produrrà il seguente output:

I moduli vengono utilizzati in tutte le applicazioni Web per accettare input dall'utente come richiesta. I dati vengono accettati come input, quindi manipolati e salvati nel database o viene eseguita qualsiasi altra operazione.

Phalcon include un componente denominato Phalcon\Forms che aiuta nella creazione e nel mantenimento delle forme.

Considera l'esempio di Blog-tutorial, che abbiamo creato nei capitoli precedenti. Include un modulo che viene utilizzato per creare una nuova categoria.

<?php echo \Phalcon\Tag::form(array("categories/create", "autocomplete" => "off")) ?>  
   <table width = "100%"> 
      <tr> 
         <td align = "left">
            <?php echo \Phalcon\Tag::linkTo(array("categories", "Go Back", "class" => "btn")) ?>
         </td> 
         <td align = "right"><
            ?php echo \Phalcon\Tag::submitButton(array("Save", "class" => "btn")) ?>
         </td> 
      <tr> 
   </table>  
   
   <?php echo $this->getContent(); ?>  
   
   <div align = "center"> 
      <h1>Create categories</h1> 
   </div>  
   <table align = "center"> 
      <tr> 
         <td align = "right"> 
            <label for = "name">Name</label> 
         </td> 
         <td align = "left"> 
            <?php echo \Phalcon\Tag::textField(array("name", "size" => 30)) ?> 
         </td> 
      </tr> 
     
      <tr> 
         <td align = "right"> 
            <label for = "slug">Slug</label> 
         </td> 
         <td align = "left"> 
            <?php echo \Phalcon\Tag::textField(array("slug", "size" => 30)) ?> 
         </td> 
      </tr> 
   </table> 
</form>

Output - Produrrà il seguente output.

I campi di input del modulo vengono visualizzati con l'aiuto di Phalcon/tagcomponente. Ogni elemento nel modulo può essere reso secondo il requisito dello sviluppatore.

Di seguito è riportata la sintassi per il valore di rendering.

echo $form->render(element-name)

Validation -

Una volta che i valori sono stati visualizzati nel controller, i valori verranno inseriti nel database con l'aiuto dei modelli. I moduli Phalcon sono integrati con il componente di convalida per offrire una convalida immediata. Validatori incorporati o personalizzati possono essere impostati su ogni elemento.

<?php  
use Phalcon\Forms\Element\Text; 
use Phalcon\Validation\Validator\PresenceOf; 
use Phalcon\Validation\Validator\StringLength;  

$name = new Text( 
   "Name" 
); 

$name->addValidator( 
   new PresenceOf([ "message" => "name is required", ]) 
); 

$form->add($name);

Output - Produrrà il seguente output.

Prima di iniziare con i concetti di Object Relational Mapper (ORM) e Object Document Mapper (ODM), è importante comprendere la differenza tra database SQL e NoSQL.

La tabella seguente evidenzia le differenze tra SQL e NoSQL:

SQL	NoSQL
Sono anche definiti come database relazionali (RDBMS)	Sono chiamati come database non relazionali o distribuiti
La struttura del database è costituita da tabelle e viste	Consiste di database basati su documenti e grafici
Include uno schema predefinito	Ha uno schema dinamico
È molto potente per definire e manipolare i dati	È potente nel mantenere i dati come raccolta di documenti

Phalcon ha la capacità di mappare con database SQL e NoSQL. Ciò si ottiene con l'aiuto di Object Document Mapper (ODM) per database NoSQL e Object Relational Mapper (ORM) per database SQL.

In Phalcon, il concetto di ORM comprende la creazione di un modello associato al nome di tabella dato, come abbiamo visto nei capitoli precedenti. Segue tutti i vincoli di integrità referenziale.

Object Document Mapper (ODM)

È un oggetto associato al database NoSQL. Come suggerisce il nome, mappa il modulo relativo al documento. Phalcon lo usa per mappare con database come MongoDB.

Esempio

Step 1 - Crea un database di MongoDB denominato “test”. Useremo questo database per eseguire la mappatura e ottenere la risposta appropriata.

Step 2- Controlla i record inseriti nel database. Il comando ad esso associato è:

db.collection.find()

Si osserva che ogni documento è mappato con ObjectId che è una caratteristica di ODM. Il valore diObjectId è unico e successivamente utilizzato per recuperare tutti i dati memorizzati rispetto a quel particolare Id.

Step 3- Impostare il modello per il database creato. Un modello è una classe che si estendePhalcon\Mvc\Collection. Test.php il modello includerà il codice seguente.

<?php 
use Phalcon\Mvc\Collection;  

class Test extends Collection { 
   public function initialize() { 
      $this->setSource("test"); 
   } 
}

Step 4 - Configurare il progetto includendo la connettività del database in services.php.

// Simple database connection to localhost 

$di->set( 
   "mongo", 
   function () { 
      $mongo = new MongoClient();  
      return $mongo->selectDB("test"); 
   }, 
   true 
); 

// Connecting to a domain socket, falling back to localhost connection 

$di->set( 
   "mongo", 
   function () { 
      $mongo = new MongoClient( 
         "mongodb:///tmp/mongodb-27017.sock,localhost:27017" 
      );  
      return $mongo->selectDB("test"); 
   }, 
   true 
);

Step 5 - Stampa i valori rispetto a ObjectId con l'aiuto di TestController.php.

<?php  

use Phalcon\Mvc\Controller;  

class TestController extends Controller { 
   public function index() { 
      // Find record with _id = "5087358f2d42b8c3d15ec4e2" 
      $test = Test::findById("5819ab6cfce9c70ac6087821"); 
      echo $test->data; 
   } 
}

L'output mostrerà i dati che corrispondono all'objectId. Se objectId non corrisponde ai record nei documenti, l'output appropriato non verrà visualizzato durante il recupero del numero di record.

Phalcon fornisce funzionalità di sicurezza con l'aiuto del componente Security, che aiuta a eseguire determinate attività come l'hashing delle password e Cross-Site Request Forgery (CSRF).

Hashing della password

Hashingpuò essere definito come il processo di conversione di una stringa di bit di lunghezza fissa in una lunghezza specificata in modo tale da non poter essere invertita. Qualsiasi modifica nella stringa di input cambierà il valore dei dati sottoposti a hashing.

La decrittazione dei dati hash avviene prendendo il valore inserito dall'utente come input e confrontando la forma hash dello stesso. Di solito per qualsiasi applicazione basata sul Web, memorizzare le password come testo normale è una cattiva pratica. È soggetto ad attacchi di terze parti poiché coloro che hanno accesso al database possono facilmente procurarsi password per qualsiasi utente.

Phalcon fornisce un modo semplice per memorizzare le password in forma crittografata che segue un algoritmo come md5, base64 o sh1.

Come visto nei capitoli precedenti, dove abbiamo creato un progetto per i blog. La schermata di accesso accetta input come nome utente e password per l'utente. Per ricevere le password dall'utente e decrittografarle in una forma particolare, viene utilizzato il seguente frammento di codice.

La password decrittografata viene quindi abbinata alla password accettata come input dall'utente. Se il valore corrisponde, l'utente può accedere con successo all'applicazione web altrimenti viene visualizzato un messaggio di errore.

<?php  
class UsersController extends Phalcon\Mvc\Controller {  
   public function indexAction() {  
   }  
   public function registerUser() { 
      $user = new Users();  
      $login    = $this->request->getPost("login"); 
      $password = $this->request->getPost("password");
      $user->login = $login;  
      
      // Store the hashed pasword 
      $user->password = $this->security->sh1($password);  
      $user->save(); 
   }  
   public function loginAction() {  
      if ($this->request->isPost()) {  
         $user = Users::findFirst(array( 
            'login = :login: and password = :password:', 
            'bind' => array( 
               'login' => $this->request->getPost("login"), 
               'password' => sha1($this->request->getPost("password")) 
            ) 
         ));  
         if ($user === false) { 
            $this->flash->error("Incorrect credentials"); 
            return $this->dispatcher->forward(array( 
               'controller' => 'users', 
               'action' => 'index' 
            )); 
         }
         $this->session->set('auth', $user->id);  
         $this->flash->success("You've been successfully logged in"); 
      }  
      return $this->dispatcher->forward(array( 
         'controller' => 'posts', 
         'action' => 'index' 
      )); 
   }  
   public function logoutAction() { 
      $this->session->remove('auth'); 
      return $this->dispatcher->forward(array( 
         'controller' => 'posts', 
         'action' => 'index' 
      )); 
   }  
}

Le password memorizzate nel database sono in un formato crittografato di sh1 algoritmo.

Una volta che l'utente immette un nome utente e una password appropriati, può accedere al sistema, altrimenti viene visualizzato un messaggio di errore come convalida.

Cross-Site Request Forgery (CSRF)

È un attacco che costringe gli utenti autenticati dell'applicazione Web a eseguire determinate azioni indesiderate. I moduli che accettano input dagli utenti sono vulnerabili a questo attacco. Phalcon cerca di prevenire questo attacco proteggendo i dati inviati tramite moduli esterni all'applicazione.

I dati in ogni forma sono protetti con l'aiuto della generazione di token. Il token generato è casuale ed è abbinato al token a cui stiamo inviando i dati del modulo (principalmente all'esterno dell'applicazione web tramite il metodo POST).

Codice:

<?php echo Tag::form('session/login') ?>  
   <!-- Login and password inputs ... -->  
   <input type = "hidden" name = "<?php echo $this->security->getTokenKey() ?>" 
      value = "<?php echo $this->security->getToken() ?>"/>  
</form>

Note - È importante utilizzare l'adattatore di sessione durante l'invio di token di modulo, poiché tutti i dati verranno mantenuti nella sessione.

Includi adattatore di sessione in services.php utilizzando il codice seguente.

/** 
   * Start the session the first time some component request the session service 
*/ 

$di->setShared('session', function () { 
   $session = new SessionAdapter(); 
   $session->start();  
   return $session; 
});