Phalcon - Guía rápida

Phalcon se presenta como uno de los marcos recientes de PHP, desarrollado por un grupo de desarrolladores entusiastas. Phalcon es una estructura de acoplamiento flexible, lo que significa que permite que sus objetos sean tratados como componentes de pegamento, según las necesidades de aplicación.

Phalcon ofrece algunas características únicas en comparación con otros marcos (tradicionales o existentes) en PHP. A continuación se presentan algunas de las características más destacadas de Phalcon:

Es un marco de código abierto de pila completa.
Un usuario necesita una cantidad bastante menor de código para aprovechar varios componentes.
Se puede utilizar para crear un marco independiente según sea necesario. Por ejemplo, si solo necesitamos el componente Cache de Phalcon, podemos usarlo en cualquier aplicación escrita en PHP puro o usando un framework.
Para un desarrollador que tenga conocimiento de Model-View-Controller (MVC) y Object- Relational Modeling (ORM), trabajar con Phalcon es como un juego de niños.

Actuación

El rendimiento de Phalcon es una característica que lo distingue de otros marcos tradicionales de PHP. Phalcon tiene una combinación de PHP y C; cada uno de ellos se puede utilizar como módulo independiente. La compilación de cada solicitud se considera a una velocidad mayor en Phalcon, lo que hace que todo parezca listo para usar.

Lenguaje C

Phalcon es compatible con C, lo que aumenta la tasa de compilación. Además, C en combinación con Phalcon proporciona Object Relational Mapping (ORM) que proporciona coherencia con los modelos creados. Cada modelo creado en Phalcon está asociado con la tabla de la base de datos relacional. ORM en Phalcon se implementa puramente en C.

Herramientas de desarrollo

Las herramientas de desarrollo se utilizan para desarrollar aplicaciones web. Estas herramientas ayudan a generar una aplicación de andamio con una combinación de todas las funciones (C - Crear, R - Leer, U - Actualizar, D - Eliminar). Las herramientas de desarrollo también incluyen soporte extensible para bibliotecas de terceros que se implementarán en Phalcon.

Mapeo relacional de objetos

Phalcon admite una amplia gama de bases de datos. No se limita al acceso a bases de datos relacionales. Es compatible con bases de datos relacionales y no relacionales, lo que es como agregar una pluma al límite del marco Phalcon.

Phalcon Vs Otros Frameworks

La siguiente tabla destaca en qué se diferencia Phalcon de otros marcos populares como Yii y Laravel.

	Yii	Laravel	Phalcon
Tipo de proyectos	Yii ayuda a crear proyectos a gran escala como foros, portales, CMS, servicios web RESTful, etc.	Laravel se utiliza para crear aplicaciones web. Es conocido por su sintaxis exquisita y sofisticada.	Phalcon se utiliza para diseñar una variedad de proyectos.
Soporte de base de datos	Yii admite todas las bases de datos relacionales y no relacionales.	Laravel admite todas las bases de datos relacionales.	Phalcon brinda el mismo soporte a las bases de datos relacionales y no relacionales.
Idioma	El marco de Yii está escrito puramente en PHP.	Laravel está escrito en PHP y sigue el patrón MVC.	Phalcon incluye PHP y C.
Escalabilidad	Yii es bastante escalable para proyectos pequeños y medianos.	La escalabilidad es alta para Laravel con todo tipo de proyectos.	Bueno para proyectos medianos.
Actuación	Comparativamente bajo.	Alto pero menor en comparación con Phalcon.	Alto rendimiento.

Prerequisites - Necesitamos la pila WAMP / LAMP / MAMP o XAMPP para este marco.

A continuación se muestran los pasos para el proceso de instalación de Phalcon framework en Windows.

Step 1 - La instalación de Phalcon depende completamente de dllarchivo. DLL (Dynamic Link Library) crea el paquete y los complementos necesarios para Phalcon.

El siguiente enlace se utiliza para descargar el archivo dll: https://phalconphp.com/en/download

Step 2- Descargue el archivo dll requerido. Verifique la configuración apropiada del sistema y descargue el archivo dll requerido. Después de descargar el archivo, extraigaphalcon-php.dll a /php/ext en el xampp carpeta.

Step 3 - Edita la ruta en php.ini file para configurarlo de manera similar a otros .dll archivos.

Step 4 - Una vez editada la ruta, reinicie el xampp/wampapilar. Será claramente visible en el tablero, una vez quedll el archivo está configurado correctamente.

Step 5 - Después de descargar el paquete, configure la variable de ruta en las propiedades del sistema.

Step 6 - el dllLos archivos y las herramientas de Phalcon juntos ayudan a crear el proyecto / aplicación web. El usuario puede verificar a través del símbolo del sistema si el marco Phalcon se ha instalado correctamente. La salida se mostrará como se muestra en la siguiente captura de pantalla.

Step 7 - Una vez que se reciba esta salida necesaria, cree un proyecto usando el siguiente comando -

phalcon create-project <project-name>

Se mostrará la siguiente salida.

Step 8- La aplicación web se ha creado correctamente. Haga clic en la siguiente URL:http://localhost/demo1

La salida se mostrará como se muestra en la siguiente captura de pantalla. Es la página de bienvenida de Phalcon PHP.

En este capítulo, discutiremos la estructura de aplicación de Phalcon. A continuación se muestra la estructura de directorios completa de un proyecto Phalcon.

Hay una carpeta raíz que se considera la code basey está disponible públicamente para el servidor web. También se llama comoweb directory. Otras carpetas fuera del directorio raíz web se consideran fuera del alcance del servidor web y del proyecto Phalcon.

Una vez que se crea un proyecto, la estructura del directorio será visible de la siguiente manera en el wamp/xamppcarpeta. Considere para el proyecto que creamos en el capítulo anterior.

A continuación se muestran las carpetas y subcarpetas del proyecto.

Aplicación

Esta carpeta consta de todos los archivos y carpetas de secuencias de comandos vitales. La aplicación web completa está diseñada sobre la base de la carpeta "aplicación". Los archivos de configuración ayudan a realizar la configuración necesaria para ejecutar la aplicación sin problemas.

A continuación se muestra la vista detallada de la carpeta de la aplicación para la aplicación web Phalcon determinada.

Consta de configuración, controladores, biblioteca, migraciones, modelos y vistas.

Config

Toda la configuración requerida para la aplicación web en Phalcon está incluida en esta carpeta. Incluye información relacionada con la conectividad de la base de datos, bibliotecas de terceros que se agregarán, si las hubiera, y los servicios que se incluirán.

Controladores

Todos los controladores están incluidos en esta carpeta. Se utilizan para procesar solicitudes y generar respuesta.

Biblioteca

Bibliotecas de terceros para la aplicación web (además del marco Phalcon existente).

Migraciones

Esta subcarpeta consta de todos los archivos asociados con la migración de datos, que también se pueden utilizar en cualquier otro marco.

Modelos

Los modelos incluyen toda la lógica necesaria para interactuar con la base de datos. En realidad, se utiliza para la representación de datos.

Puntos de vista

Constituye todas las vistas relacionadas con la aplicación web. Estas vistas se muestran a los usuarios finales con la ayuda de los controladores.

Cache

Este directorio incluye datos relacionados con el almacenamiento en caché, lo que ayuda a mejorar el rendimiento.

Público

Incluye todas las carpetas para fines de gestión de activos que se componen de CSS, JavaScript, archivos que se cargarán y algunos metadatos.

Archivo .htaccess

Los servidores web que se ejecutan en el uso del software Apache Web Server .htaccesscomo archivo de configuración. Cuando se coloca en un directorio, toda la configuración necesaria se carga tan pronto como se inicia el servidor.

Por ejemplo, es posible configurar un sitio web para que esté disponible solo para direcciones IP específicas con .htaccess archivo.

Model View Controller (MVC)es un diseño de software y un patrón estructural para desarrollar aplicaciones basadas en web. Esta arquitectura de software separa la representación de la información de la interacción del usuario con ella.

El modelo MVC define las aplicaciones web con tres capas lógicas.

Modelo

Los modelos son objetos que representan el conocimiento. Debe haber una relación de uno a uno entre el modelo y sus partes. Incluye toda la lógica que se utilizará para la conectividad de la base de datos y la realización de operaciones CRUD.

Ver

Una vista es una representación visual de su modelo. View interactúa con el modelo o sus partes y obtiene los datos necesarios para la presentación del modelo. Esto se logra enviando solicitudes y recibiendo las respuestas adecuadas. Ver incluye todos los datos que ve el usuario final.

Controlador

Un controlador actúa como intermediario entre el usuario y el sistema (modelo y vista). Acepta la solicitud del usuario, a través de la vista la envía al modelo. El modelo lo manipula y envía la respuesta al controlador, que se muestra como la salida al usuario final a través de la vista.

El controlador recibe dicha salida de usuario y la traduce en los mensajes apropiados. Estos mensajes se utilizan por vista para mostrarse como respuestas apropiadas.

Flujo de trabajo en Phalcon

El flujo de trabajo en Phalcon es el siguiente:

El usuario interactúa con la interfaz de usuario (vista) y la interacción se mantiene con la ayuda de algún método / evento.
Estos métodos y eventos son manejados por el controlador.
El controlador accede al modelo actualizando la acción del usuario.
View usa el modelo para generar un resultado apropiado.
Ver obtiene datos de su modelo. El modelo no tiene interacción directa con la vista.
La interfaz de usuario espera nuevas interacciones del usuario, que comienza con un nuevo ciclo de solicitud y respuesta.

Phalcon incluye directorios para Model, View y Controller. La siguiente captura de pantalla ofrece un escenario mejor.

Toda la lógica empresarial se describe en el controlador y el modelo interactúa con la base de datos que incluye todos los archivos con respecto a todas y cada una de las tablas.

Note -

Todos los controladores creados en la aplicación web Phalcon se extienden Phalcon\Mvc\Controller.
Todos los modelos asociados con las tablas de la base de datos se extienden \Phalcon\Mvc\Model.

La carpeta de configuración de la aplicación web incluye los siguientes archivos:

config.php
loader.php
services.php

config.php

Incluye las configuraciones para la conectividad y el enrutamiento de la base de datos según la ruta del directorio.

<?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

Extiende la clase existente de \Phalcon\Loader(). La clase de cargador registra los directorios que requieren la aplicación 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

Este archivo asocia todas las funciones que implementan los servicios de un proyecto web. ImplementaPhalcon\Diinterfaz. También implementa una inyección de dependencia de los servicios cargándolos.

Básicamente, el archivo services.php dentro de la carpeta de configuración actúa como un contenedor de todos los servicios. Esta interfaz ayuda a inicializar todos los servicios, como la conexión a la base de datos, la configuración de cookies, la creación de una nueva sesión o la conexión con la base de datos 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; 
});

En el marco MVC, "C" significa el controlador que se refiere a los cuadros de distribución de la aplicación web. Las acciones realizadas por el controlador ayudan a pasar parámetros a la vista para que pueda mostrar y responder a la entrada del usuario en consecuencia.

Por ejemplo, si nos registramos a través de un formulario de registro que incluye detalles del usuario como nombre de usuario, dirección de correo electrónico y contraseña, y hacemos clic en el botón Enviar, los datos insertados o publicados por el usuario se envían a través del controlador con la ayuda de acción o función asociada.

Características de un controlador

UN controller acepta entradas de la vista e interactúa con el modelo asociado.

Ayuda a actualizar el estado del modelo enviando comandos al modelo. También puede enviar comandos a la vista asociada, lo que ayuda a cambiar la presentación de la vista según el estado del modelo.
Un controlador actúa como intermediario entre el modelo y la vista.

Flujo de trabajo de un MVC en Phalcon

La siguiente ilustración muestra el flujo de trabajo de MVC en Phalcon

Pasos para crear un controlador en Phalcon

Step 1- Redirigir a la ruta del proyecto con la ayuda del símbolo del sistema. Consulte la siguiente captura de pantalla.

Como se menciona en la captura de pantalla anterior, "demo" es el proyecto asociado con el marco PHP de Phalcon.

Step 2 - Utilice el siguiente comando para crear un controlador asociado.

phalcon controller <controller-name>

A continuación se muestra el resultado de la ejecución exitosa del comando anterior.

Note- Los nombres de clase de los controladores deben tener el sufijo "controlador". Esto implica una buena convención de nomenclatura que se sigue en Phalcon.

Por defecto, cuando la aplicación se crea en el marco PHP de Phalcon, incluye un controlador llamado "IndexController". Este controlador se invoca de forma predeterminada para activar las acciones.

Este controlador se extiende por controlador-base a diferencia de otros controladores que se extiende \Phalcon\Mvc\Controller.

Code -

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

Output -

El modelo en la arquitectura MVC incluye la lógica de aplicación. El modelo es la interacción central con la base de datos. Debería poder gestionar la actualización, eliminación, inserción y obtención de registros según la solicitud del usuario.

Para comprender la interacción del modelo en el marco PHP de Phalcon, se deben seguir los siguientes pasos.

Step 1 - Creación de base de datos.

Para cualquier LAMP, WAMP, XAMPP pila de software, es bastante fácil crear una base de datos con la ayuda de phpmyadmin herramienta de base de datos.

A continuación se muestra la consulta SQL para crear una base de datos.

create database <database-name>

Step 2 - En el phpmyadmin sección, haga clic en la pestaña Bases de datos, mencione el nombre de la base de datos y luego haga clic en el botón Crear como se muestra en la siguiente captura de pantalla.

Step 3 - Una vez que la base de datos se haya creado correctamente, cree una tabla que ayudará a su asociación para crear un modelo en el marco Phalcon.

Utilice la siguiente consulta para crear una nueva tabla denominada "usuarios".

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 vez creada la tabla, su estructura se parece a la que se muestra en la siguiente captura de pantalla.

Step 4- Para crear un modelo asociado con la tabla 'Usuarios' que creamos en el paso anterior, abra la instancia del símbolo del sistema. Es importante redirigir a la ruta del proyecto adecuada. Antes de eso, es vital verificar si la configuración de la base de datos se ha establecido correctamente como se muestra en la siguiente captura de pantalla.

Step 5 - Utilice el siguiente comando para crear cualquier modelo en el marco de Phalcon.

phalcon model <model-name>

A continuación se muestra el resultado de la ejecución del comando anterior.

Esto implica que el modelo se ha creado con éxito.

Step 6- El modelo creado con éxito está presente en la carpeta de modelos. Utilice la siguiente ruta para ver dónde se crea el modelo.

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

A continuación se muestra el código completo para 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- El controlador interactúa con el modelo y la vista para obtener el resultado necesario. Al igual que con el modelo, use el siguiente terminal de comando para crear un controlador.

Phalcon controller <controller-name>

En la ejecución exitosa del comando anterior, el resultado es el siguiente.

A continuación se muestra el código para UserController.php.

<?php  

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

La salida se mostrará si presionamos la siguiente URL: http://localhost/demo1/users

Las vistas son información que se presenta al usuario final. Una vista puede considerarse como una página web con la respuesta adecuada que se mostrará. La respuesta se recibe a través del controlador que interactúa con el modelo.

Específicamente en Phalcon, la vista consta de código Volt, PHP y HTML. Hay disponible un conjunto de delimitadores especiales para ingresar en modo Volt.{% ... %} se utiliza para ejecutar declaraciones como bucles for o asignar valores, y {{ ... }} imprime el resultado de una expresión en la plantilla.

Las vistas en Phalcon se clasifican básicamente en dos tipos:

Volt
phtml

Voltio

A continuación se muestra la captura de pantalla de la salida que habíamos creado para el proyecto. demo1 en el capítulo anterior.

Esta salida se logra con la ayuda de file views/index/index.volt.

Características de los archivos Volt

Es una plantilla escrita en lenguaje C y es considerablemente más rápida en comparación con otros lenguajes.
Incluye un conjunto de componentes altamente integrados, que son muy beneficiosos en Phalcon.
También se puede utilizar como componente independiente.
Volt está compilado en código PHP puro.

A continuación se muestra el código para index.volt que se carga por defecto para cualquier proyecto.

<!--<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>-->

Representación jerárquica

Las vistas en Phalcon admiten la representación jerárquica y Phalcon\Mvc\Viewse utiliza como componente de renderizado predeterminado. Este componente usa PHP como motor de plantilla en comparación con los archivos volt que usa C como lenguaje de plantilla.

Estas vistas deberían tener .phtmlextensión. El directorio predeterminado de vistas para el proyecto dado consta de los siguientes tres archivos:

Action view- Esta vista se llama para ejecutar una acción en particular. Se llama cuando se ejecuta la acción "mostrar".
Controller layout- Esta vista está presente dentro de la carpeta de diseños. Por ejemplo,C:\xampp\htdocs\demo\app\views\layouts. Invoca las llamadas al método asociadas con el controlador apropiado. El código implementado en el diseño se implementará cuando sea necesario.
Main layout - Esta vista de diseño invocará la acción principal y se mostrará para cada controlador o acción dentro de la aplicación web.

Diferencia entre archivos .volt y .phtml

.voltio	.phtml
La extensión .volt se usa cuando el motor de plantillas configurado en la aplicación está escrito en C	.phtml se usa cuando el motor de plantillas es PHP mismo
Se puede utilizar como componente independiente.	No se puede utilizar como componente independiente
Las vistas de Volt se compilan en código PHP	Los archivos phtml en sí incluyen código PHP, por lo que no es necesario compilarlos en el marco de Phalcon.

Variables

Las variables se asignan y cambian en la plantilla usando 'set'.

Declarar una matriz

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

Declarar una cadena

{% set name = ”John Kennedy” %}

Comentarios

Los comentarios también se pueden agregar a una plantilla usando el {# ... #}delimitadores. Todo el texto dentro de ellos simplemente se ignora en la salida final.

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

Ejemplo

{% 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>

Salida

El código producirá la siguiente pantalla de salida:

El componente enrutador permite definir rutas que se mapean a los controladores o manejadores que deben recibir la solicitud. Un enrutador analiza un URI según la información recibida.

Cada enrutador de la aplicación web tiene dos modos:

Modo MVC
Modo de solo partido

El primer modo es ideal para trabajar con aplicaciones MVC. A continuación se muestra la sintaxis para definir una ruta en Phalcon.

$router = new Router();  

// Define a route 

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

Ejemplo

Para buscar una categoría, creemos una ruta en routes.php de la carpeta de configuración.

Considere la posibilidad de crear una ruta que llamará a un método de inicio de sesión cuando invocamos “UsersController”. En tal caso, se sugiere crear una ruta que mapee la URL dada.

<?php  

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

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

Salida

El código producirá la siguiente salida:

En este capítulo, discutiremos la conectividad de la base de datos relacionada con Phalcon.

Creación de base de datos y diseño

Nos centraremos en la creación de una base de datos para blogs que mantenga publicaciones junto con las categorías según las entradas de los usuarios.

Nombre de la base de datos: blog-tutorial

Consulta utilizada para crear la base de datos -

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

Después de la creación de la base de datos, la base de datos se enumerará como se muestra en la siguiente captura de pantalla.

Phalcon usa comandos para la creación de models, controllers, e incluso proyectos. Vamos a ver cómo funciona.

Step 1 - Crea un proyecto llamado blog-tutorial.

Step 2 - Configurar la aplicación web que se conecta a la base de datos que creamos para la gestión de blogs.

<?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/', 
   ) 
));

Hemos utilizado una base de datos MySQL en nuestra aplicación. Si quisiéramos cambiar el software de la base de datos a mitad de camino, no sería demasiado difícil, siempre que tengamos la misma estructura de datos en nuestra nueva base de datos.

PostgreSQL

Configure la aplicación web que se conectará a la base de datos PostgreSQL.

Esto se puede lograr usando el siguiente código. Los servicios incluiránPhalcon\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

Para implementar la conexión SQLite, la configuración debe extenderse con Phalcon\Db\Adapter\Pdo\Sqlite clase abstracta.

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

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

Oráculo

Para implementar la conexión de la base de datos Oracle en Phalcon, la configuración debe ampliarse con Phalcon\Db\Adapter\Pdo\Oracle clase abstracta.

<?php  

use Phalcon\Db\Adapter\Pdo\Oracle;  

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

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

El andamio generalmente se refiere a un tipo de generación de código donde lo apuntamos a una base de datos de aplicaciones web, lo que da como resultado la creación de una aplicación CRUD (Crear, Leer, Actualizar, Eliminar) básica.

Antes de diseñar una aplicación CRUD, es importante diseñar tablas de base de datos según la necesidad de la aplicación.

Step 1 - Cree una aplicación de andamio que incluya todas las operaciones de crud.

Command: phalcon scaffold <table-name>

Una vez ejecutado, el generador de andamios de Phalcon creará archivos y carpetas que se describen en la siguiente tabla.

Step 2 - Crear una página de índice (combinación de phtml y volt).

Código que se incluirá en index.phtml en la carpeta de usuarios.

<?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>

Archivo predeterminado index.volt incluirá el siguiente código.

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

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

La ejecución exitosa del código anterior produce el siguiente resultado.

Step 3 - Cambiar con los respectivos modelos.

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 función nombrada ‘initialize’ ayuda a implementar la relación entre id y users_id en la tabla Publicaciones, lo que significa que cada usuario único tiene muchas publicaciones asociadas en la tabla.

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 función ‘initialize’ incluye restricción de relación que menciona la relación de clave externa y clave principal con la tabla.

users_id se refiere a la identificación en la tabla "Usuarios".

categories_id se refiere a id en la tabla "Categorías".

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"); 
   } 
}

Similar al modelo de Usuarios, el ‘initialize’ función especifica que incluye muchos categories_id para la publicación dada.

Diseño de la página de inicio de sesión

Creando Vistas

A continuación se muestra la estructura completa del proyecto Blog-tutorial-master.

La vista asociada para mostrar la página de inicio después de que el usuario inicia sesión correctamente es “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>

Gestión por categorías

Lenguaje de consulta Phalcon (PHQL) también llamado PhalconQL es un dialecto SQL de alto nivel que estandariza las consultas SQL para los sistemas de bases de datos compatibles con Phalcon.

Incluye un analizador, escrito en C, que traduce la sintaxis en el RDBMS de destino.

Aquí hay una lista de algunas de las características destacadas del lenguaje de consulta de Phalcon:

Para la seguridad de la aplicación web, utiliza parámetros vinculados.
Las tablas se tratan como modelos, mientras que las columnas se tratan como atributos de clase.
Todas las declaraciones de manipulación de datos se utilizan para evitar la pérdida de datos que puede ocurrir.
La inyección de SQL se evita manteniendo la llamada de consulta SQL de una en una.

Crear una consulta PHQL

Las consultas se crean instanciando la clase Phalcon\Mvc\Model\Query.

Ejemplo

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

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

En los capítulos anteriores, hemos visto el funcionamiento de la aplicación web de andamios denominada tutorial de blog. Incluía categorías de búsqueda por nombre o babosa.

A continuación se muestra el código incluido para 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 consulta PHQL ejecutada (resaltada) en el controlador obtendrá todos los resultados según la condición de búsqueda. El resultado de cualquier consulta de búsqueda según la condición se mostrará como en la captura de pantalla.

A continuación se muestra la salida recibida en la ejecución exitosa del código anterior.

Ciclo de vida de PHQL

Al ser un lenguaje de alto nivel, PHQL brinda a los desarrolladores la capacidad de personalizar y personalizar varios aspectos según los requisitos.

A continuación se muestra el ciclo de vida de cada declaración PHQL ejecutada en Phalcon:

Cada declaración PHQL se analiza y convierte como una Representación Intermedia (IR) que es completamente independiente del SQL implementado por el sistema de base de datos.
El IR se convierte en una declaración SQL según el sistema de base de datos que se utiliza en la aplicación web. Las sentencias SQL generadas están asociadas con el modelo.
Todas las declaraciones PHQL se analizan una vez y se almacenan en la memoria caché. Si se ejecuta el mismo resultado de instrucción, ayudará a un rendimiento más rápido.

La migración de la base de datos es importante por las siguientes razones:

La migración de la base de datos ayuda a transferir datos entre los tipos de almacenamiento especificados.
La migración de la base de datos se refiere al contexto de las aplicaciones basadas en web que migran de una plataforma a otra.
Este proceso generalmente se lleva a cabo para realizar un seguimiento de los datos que están desactualizados.

Phalcon realiza el proceso de migración de la base de datos de la siguiente manera:

Step 1 - Crea un proyecto llamado “dbProject” en xampp/wamp directorio.

Step 2 - Configure el proyecto con la conectividad de base de datos adecuada.

<?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- Ejecutar el comando de migración de tablas incluidas dentro de la base de datos “demodb”. Por ahora, incluye una tabla "usuarios".

Step 4 - Los archivos de la base de datos migrados se almacenan dentro del directorio de migraciones dentro de la carpeta "aplicación".

Por lo tanto, las tablas se migran correctamente.

Comprensión de la anatomía de los archivos migrados

El archivo migrado tiene una clase única que se extiende Phalcon\Mvc\Model\Migrationclase. La clase Migration en Phalcon incluye los métodosup() y down(). losup() El método se utiliza para realizar la migración, mientras que el método descendente revierte la operación.

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 clase UserMigration_100 como se muestra en el ejemplo anterior incluye una matriz asociativa con cuatro secciones que son:

Columns - Incluye un conjunto de columnas de tabla.
Indexes - Incluye un conjunto de índices de tablas.
References - Incluye todas las restricciones de integridad referencial (clave externa).
Options - Matriz con un conjunto de opciones de creación de tablas.

Como se ve en el ejemplo anterior, la versión 1.0.0 de la base de datos se migró correctamente. Phalcon puede incluir y ejecutar múltiples procesos de migración dependiendo de cómo se mantenga el contenido de la base de datos.

Cookies también conocidas como browser cookiesson pequeños archivos de texto almacenados en el navegador. Guarda toda la información relacionada con la identidad del usuario. Esta información se utiliza para validar a los usuarios una vez que navegan por diferentes páginas.

Hay dos tipos diferentes de cookies:

Session Cookies- Este tipo de cookies permanecen en el navegador y retienen información hasta que se cierra el navegador. Tan pronto como se abra el navegador, se tratará como una nueva sesión para el mismo usuario.
Persistent Cookies- Incluye una vida útil estipulada y permanece en el navegador dentro de la vida útil determinada. Los sitios web que utilizan cookies persistentes realizan un seguimiento de todos y cada uno de los usuarios, incluso si el usuario cierra el navegador.

Analicemos ahora cómo funcionan las cookies en Phalcon.

Galletas en Phalcon

Usos de Phalcon Phalcon\Http\Response\Cookiescomo almacenamiento global de cookies. Las cookies se almacenan en Phalcon mientras se envía una solicitud al servidor.

A continuación se muestra la sintaxis para configurar una cookie:

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

Considere el siguiente ejemplo. Usando el siguiente código, crearemos cookies del usuario cuando este inicie sesión en la aplicación 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 
      ); 
   } 
}

Las cookies cifradas se mostrarán como salida.

Descripción

Cookie nombrada “loginAction” ha sido creado con valor “abc”.

El método “indexAction” comprueba si la cookie existe e imprime el valor en consecuencia.

Cifrado de cookies

Las cookies en Phalcon se cifran antes de enviarse al servidor como una solicitud y se descifran tan pronto como obtenemos una respuesta adecuada del servidor. Esto asegura la seguridad de los usuarios autorizados.

Siempre se sugiere evitar el almacenamiento de datos confidenciales en cookies, a pesar de la funcionalidad de cifrado y descifrado. La configuración para el cifrado de cookies se incluye enservices.php archivo.

/** 
   * 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 -

Siempre se sugiere utilizar cifrado al enviar cookies al servidor.
Si no se utiliza el cifrado, toda la aplicación interna quedará expuesta al atacante.
También se recomienda almacenar pequeños datos y literales en las cookies.

Las sesiones son almacenamiento de información del lado del servidor que ayuda en la interacción del usuario con el sitio web o la aplicación web. Cada sesión se define de forma única con un ID de sesión, que se pasa al servidor web cada vez que el navegador realiza una solicitud HTTP. El ID de sesión se empareja cada vez con la base de datos interna de modo que se recuperan todas las variables almacenadas.

Sesiones en Phalcon

Phalcon utiliza componentes de sesión que incluyen envoltorios para acceder a los datos de la sesión.

Las siguientes son las características de Phalcon:

Los datos de la sesión se pueden aislar de otros componentes del mismo dominio.
Según las necesidades de la aplicación, el valor de la sesión se puede cambiar con la ayuda del adaptador de sesión.

Iniciar una sesión en Phalcon

Todas las actividades de la sesión están asociadas con los archivos del adaptador que se declaran en Services.php archivo dentro del /config carpeta de la aplicación web.

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

Crear una sesión

Step 1 - Cree un controlador de sesión para crear instancias de una sesión de modo que los datos se puedan recuperar de forma adecuada.

Step 2 - Crear una sesión con nombre y valor.

<?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); 
      } 
   } 
}

El código anterior produce la siguiente salida.

Eliminar una sesión

Es posible destruir la sesión o desarmar algunos valores variables dentro de la sesión en Phalcon.

A continuación se muestra la sintaxis para desarmar los valores de las variables en la sesión.

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

Como se muestra en el ejemplo anterior, el nombre de variable creado en la sesión es “data-content” que se puede eliminar con el siguiente código.

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

A continuación se muestra la sintaxis para destruir la sesión completa.

$this->session->destroy();

Phalcon incluye un componente Phalcon\Translate que proporciona soporte multilingüe y es muy útil para crear páginas web, que se traducen en varios idiomas.

Incluye un adaptador que ayuda a enlazar matrices y ayuda a leer los mensajes de traducción.

Ejemplo

Creemos una salida con la ayuda del componente Traducir en Phalcon, que ayudará a mostrar la salida según el idioma sugerido.

Step 1- Phalcon da libertad a cada desarrollador para organizar cadenas de traducción. Considere mantener dos archivos diferentes a saber:en.php (para cadenas en inglés) y fr.php (para cuerdas francesas).

El archivo contendrá una matriz de pares clave-valor, donde las claves son únicas y los valores diferirán según la traducción necesaria.

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 - En una aplicación, cree un UserController que tomará parámetros sobre qué archivo se debe utilizar para la traducción.

<?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(); 
   } 
}

Para el método predeterminado, se toman dos parámetros, el primero es el nombre y el segundo es la canción favorita del usuario. Más tarde, la funcióngetMessageTranslation se está llamando que devuelve la salida deseada.

Por ahora, queremos la salida en inglés.

Step 3 - El asociado code view demo\app\views\User\index.volt incluirá el siguiente código:

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

Si queremos que la salida completa se muestre en francés, solo necesitamos cambiar el nombre del archivo.

require "fr.php";

A continuación se muestra la salida en francés.

Los activos tienen que ver con los componentes adicionales además del marco existente en Phalcon. Phalcon tiene un administrador de activos que ayuda a administrar todos los componentes de los activos como archivos CSS o JS.

Los métodos comunes utilizados son:

Método	Importancia
__construct ($ opciones variables)	Inicializa el componente Phalcon \ Assets \ Manager
addCss (cadena $ ruta, variable $ local, variable $ filtro, variable $ atributos)	Agrega un recurso CSS de la colección 'css' a una vista particular
addJs (cadena $ ruta, variable $ local, variable $ filtro, variable $ atributos)	Agrega un recurso de JavaScript a la colección 'js'

Ejemplo

Considere el proyecto de muestra de Phalcon “vokuro” cuál es la mejor ilustración para agregar cssarchivos. Incluirá assets / Manager para invocar todos loscss archivos.

El controlador predeterminado del proyecto invocará todos los css archivos.

<?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; 
}

Los activos se administrarán dentro de las vistas, que mostrarán archivos css como salida.

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>

Salida

Producirá la siguiente salida:

Los formularios se utilizan en todas las aplicaciones web para aceptar entradas del usuario como solicitud. Los datos se aceptan como entrada, luego se manipulan y guardan en la base de datos o se realiza cualquier otra operación.

Phalcon incluye un componente llamado Phalcon\Forms que ayuda en la creación y mantenimiento de formas.

Considere el ejemplo de Blog-tutorial, que creamos en los capítulos anteriores. Incluye un formulario que se utiliza para crear una nueva categoría.

<?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 - Producirá la siguiente salida.

Los campos de entrada del formulario se representan con la ayuda de Phalcon/tagcomponente. Cada elemento del formulario se puede representar según los requisitos del desarrollador.

A continuación se muestra la sintaxis para representar el valor.

echo $form->render(element-name)

Validation -

Una vez que los valores se representan en el controlador, los valores se ingresarán en la base de datos con la ayuda de modelos. Los formularios de Phalcon están integrados con el componente de validación para ofrecer una validación instantánea. Se pueden configurar validadores integrados o personalizados para cada 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 - Producirá la siguiente salida.

Antes de comenzar con los conceptos de Object Relational Mapper (ORM) y Object Document Mapper (ODM), es importante comprender la diferencia entre las bases de datos SQL y NoSQL.

La siguiente tabla destaca las diferencias entre SQL y NoSQL:

SQL	NoSQL
También se denominan bases de datos relacionales (RDBMS)	Se denominan bases de datos distribuidas o no relacionales
La estructura de la base de datos está constituida por tablas y vistas.	Consiste en bases de datos basadas en documentos y gráficos
Incluye un esquema predefinido	Tiene un esquema dinámico
Es muy poderoso para definir y manipular datos.	Es poderoso para mantener datos como colección de documentos.

Phalcon tiene la capacidad de mapear con bases de datos SQL y NoSQL. Esto se logra con la ayuda de Object Document Mapper (ODM) para la base de datos NoSQL y Object Relational Mapper (ORM) para la base de datos SQL.

En Phalcon, el concepto ORM comprende la creación de un modelo asociado con el nombre de tabla dado, como hemos visto en los capítulos anteriores. Sigue todas las restricciones de integridad referencial.

Mapeador de documentos de objetos (ODM)

Es un objeto asociado a la base de datos NoSQL. Como sugiere el nombre, asigna el módulo relacionado con el documento. Phalcon lo usa para mapear con bases de datos como MongoDB.

Ejemplo

Step 1 - Crea una base de datos de MongoDB llamada “test”. Usaremos esta base de datos para mapear y obtener la respuesta adecuada.

Step 2- Verifique los registros insertados en la base de datos. El comando asociado con él es:

db.collection.find()

Se observa que cada documento se asigna con ObjectId, que es una característica de ODM. El valor deObjectId es único y luego se usa para obtener todos los datos almacenados con respecto a esa identificación en particular.

Step 3- Configurar modelo para la base de datos creada. Un modelo es una clase que se extiendePhalcon\Mvc\Collection. Test.php modelo incluirá el siguiente código.

<?php 
use Phalcon\Mvc\Collection;  

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

Step 4 - Configurar el proyecto incluyendo la conectividad de la base de datos en 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 - Imprimir los valores con respecto a ObjectId con la ayuda de 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; 
   } 
}

La salida mostrará datos que coincidan con el objectId. Si el objectId no coincide con los registros de los documentos, no se mostrará la salida adecuada a medida que se recupere el número de registros.

Phalcon proporciona funciones de seguridad con la ayuda del componente de seguridad, que ayuda a realizar ciertas tareas como hash de contraseña y Cross-Site Request Forgery (CSRF).

Contraseña hash

Hashingse puede definir como el proceso de convertir una cadena de bits de longitud fija en una longitud especificada de tal manera que no se pueda invertir. Cualquier cambio en la cadena de entrada cambiará el valor de los datos hash.

El descifrado de los datos hash se realiza tomando el valor ingresado por el usuario como entrada y comparando el formato hash del mismo. Por lo general, para cualquier aplicación basada en web, almacenar las contraseñas como texto sin formato es una mala práctica. Es propenso a ataques de terceros, ya que aquellos que tienen acceso a la base de datos pueden obtener fácilmente contraseñas para cualquier usuario.

Phalcon proporciona una forma sencilla de almacenar contraseñas en forma cifrada que sigue un algoritmo como md5, base64 o sh1.

Como se vio en los capítulos anteriores, donde creamos un proyecto para blogs. La pantalla de inicio de sesión acepta la entrada como nombre de usuario y contraseña para el usuario. Para recibir las contraseñas del usuario y descifrarlas en una forma particular, se utiliza el siguiente fragmento de código.

Luego, la contraseña descifrada se compara con la contraseña aceptada como entrada del usuario. Si el valor coincide, el usuario puede iniciar sesión correctamente en la aplicación web; de lo contrario, se muestra un mensaje de error.

<?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' 
      )); 
   }  
}

Las contraseñas almacenadas en la base de datos están en formato cifrado de sh1 algoritmo.

Una vez que el usuario ingresa un nombre de usuario y contraseña apropiados, el usuario puede acceder al sistema; de lo contrario, se muestra un mensaje de error como validación.

Falsificación de solicitud entre sitios (CSRF)

Es un ataque que obliga a los usuarios autenticados de la aplicación web a realizar determinadas acciones no deseadas. Los formularios que aceptan aportaciones de los usuarios son vulnerables a este ataque. Phalcon intenta prevenir este ataque protegiendo los datos que se envían a través de formularios fuera de la aplicación.

Los datos de cada formulario se protegen con la ayuda de la generación de tokens. El token generado es aleatorio y coincide con el token al que enviamos los datos del formulario (principalmente fuera de la aplicación web a través del método POST).

Código:

<?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 - Es importante utilizar el adaptador de sesión al enviar tokens de formulario, ya que todos los datos se mantendrán en la sesión.

Incluir adaptador de sesión en services.php usando el siguiente código.

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

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

↰ Previous page