Sunteți pe pagina 1din 27

phalcon

#phalcon
Tabla de contenido
Acerca de 1

Capítulo 1: Empezando con phalcon 2

Observaciones 2

Enlaces útiles: 2

Versiones 2

Examples 3

Instalación 3

Windows 3

Plataformas linux 3

Usuarios de Ubuntu 4

Mac OS X 4

Homebrew 4

Capítulo 2: Encargado de eventos 6

Examples 6

Comprobación dinámica de ACL 6

Capítulo 3: Enrutamiento y despacho 7

Examples 7

Rutas API RESTful para aplicaciones de múltiples módulos 7

Configurar dinámicamente las rutas del módulo. 7

Capítulo 4: Filtrado y desinfección 9

Examples 9

Conveniente desinfección en el modelo 9

Capítulo 5: Gestión de base de datos 10

Examples 10

Usando SQL estándar directamente con modelos 10

Gestión de bases de datos utilizando el modelo Phalcon 10

Configuración del servicio de conexión por defecto 12

Caching Modelos Metadatos. 12

Capítulo 6: Incubadora 14

Examples 14
Introducción 14

Instalación 14

Instalación vía Composer 14

Instalación vía Github 15

Instalación vía manual. 15

Uso 16

Cargando la Incubadora en tu proyecto 16

Capítulo 7: Trabajando con ACL 17

Sintaxis 17

Observaciones 17

Examples 17

Creando un ACL 17

Definición de control de acceso y consulta de una ACL 18

Condición adicional en ACL 18

Objetos como roles y recursos. 18

Capítulo 8: Validación 21

Observaciones 21

Examples 21

Construido en validadores 21

Componente de validación personalizado reCaptcha de Google 23

Creditos 24
Acerca de
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: phalcon

It is an unofficial and free phalcon ebook created for educational purposes. All the content is
extracted from Stack Overflow Documentation, which is written by many hardworking individuals at
Stack Overflow. It is neither affiliated with Stack Overflow nor official phalcon.

The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to info@zzzprojects.com

https://riptutorial.com/es/home 1
Capítulo 1: Empezando con phalcon
Observaciones
Phalcon es un framework de código abierto y de pila completa para PHP.

La funcionalidad se expone como clases de PHP listas para ser utilizadas. Escrito como una
extensión C, está optimizado para un rendimiento extremadamente alto, siendo el marco más
rápido posible disponible para los desarrolladores de PHP.

Enlaces útiles:

Recurso Enlazar

Equipo https://phalconphp.com/en/team

Documentación https://docs.phalconphp.com/

Instrucciones de descarga e instalación https://phalconphp.com/en/download

Foro https://forum.phalconphp.com/

Blog https://blog.phalconphp.com/

GitHub https://github.com/phalcon/cphalcon

Mapa vial https://github.com/phalcon/cphalcon/wiki/Roadmap

Construido con Phalcon https://builtwith.phalconphp.com/

Versiones

Versión Fecha de lanzamiento

2.0.0 2014-04-17

2.0.1 2015-05-08

2.0.2 2015-05-25

2.0.3 2015-06-10

2.0.4 2015-07-07

https://riptutorial.com/es/home 2
Versión Fecha de lanzamiento

2.0.5 2015-07-14

2.0.6 2015-07-21

2.0.7 2015-08-17

2.0.8 2015-09-25

2.0.9 2015-11-23

2.0.10 2016-02-04

2.0.11 2016-05-04

2.0.12 2016-05-16

2.0.13 2016-05-24

3.0.0 2016-07-29

3.0.1 2016-08-24

Examples
Instalación

Descargue los archivos de instalación de la página de descarga dedicada de Phalcon, así como
también busque manuales sobre cómo hacer que Phalcon funcione con plataformas populares.

Windows
Coloque los archivos DLL reales en un directorio adecuado para ampliar la funcionalidad de PHP.
Para XAMPP use xampp\php\ext\ - y para WAMP use wamp\bin\php\php*\ext\ derectory. Luego
habilite Phalcon agregando extension=php_phalcon.dll al archivo php.ini apropiado. Reinicie el
servidor web y Phalcon debería estar disponible.

Plataformas linux
Para compilar la versión deseada de Phalcon, primero instale las fuentes PHP junto con algunas
otras herramientas necesarias:

#Ubuntu
sudo apt-get install php5-dev php5-mysql gcc libpcre3-dev

https://riptutorial.com/es/home 3
#Fedora
sudo yum install php-devel php-mysqlnd gcc libtool

#RHEL
sudo yum install php-devel php-mysql gcc libtool

#Suse
yast2 -i php5-pear php5-devel php5-mysql gcc

#OS X (Using Homebrew)


brew tap homebrew/dupes
brew tap homebrew/versions
brew tap homebrew/php
brew install php5x php5x-phalcon # Where "x" - minor number of PHP

Después de que todos estén correctamente instalados, Phalcon puede ser compilado:

git clone --depth=1 git://github.com/phalcon/cphalcon.git


cd cphalcon/build
sudo ./install

(Elija la versión deseada en lugar de usar git://github.com/phalcon/cphalcon.git ) Luego, la


extensión Phalcon debería estar disponible en los directorios de PHP. Todo lo que queda es
incluir la extension=phalcon.so en el archivo php.ini deseado. Reinicie el servidor web y debería
estar disponible.

Usuarios de Ubuntu
Es posible instalar Phalcon directamente desde los repositorios usando los siguientes comandos:

sudo apt-add-repository ppa:phalcon/stable


sudo apt-get update
sudo apt-get install php5-phalcon

Mac OS X
Homebrew
Si tiene instalado brew, primero debe tocar homebrew-php:

brew tap homebrew/homebrew-php

Después de eso necesitas determinar tu versión de PHP. Esto se puede hacer a través del
comando:

php -v

El comando producirá algo similar a PHP 5.6.22 que desea que el primer y segundo número, que

https://riptutorial.com/es/home 4
son 5 y 6 en este caso. Luego ejecuta el siguiente comando para instalar la versión adecuada
(reemplazando 5 y 6 con la versión que tienes):

brew install php56-phalcon

Fuentes:

• https://docs.phalconphp.com/en/latest/reference/install.html#mac-os-x

Lea Empezando con phalcon en línea: https://riptutorial.com/es/phalcon/topic/4559/empezando-


con-phalcon

https://riptutorial.com/es/home 5
Capítulo 2: Encargado de eventos
Examples
Comprobación dinámica de ACL

Cree una clase de seguridad para ejecutar su lógica ACL.

<?php

namespace Plugins;

use Phalcon\Events\Event;
use Phalcon\Mvc\Dispatcher;
use Phalcon\Acl;
use Phalcon\Acl\Role;
use Phalcon\Acl\Resource;
use Phalcon\Acl\Adapter\Memory as AclList;

class Security extends \Phalcon\Mvc\User\Plugin


{
public function beforeExecuteRoute(Event $event, Dispatcher $dispatcher)
{
// your acl logic here
}
}

Conecte la clase de Seguridad al despachador, para que se ejecute en beforeExecuteRoute .

$di = new \Phalcon\DI\FactoryDefault();


$eventsManager = $di['eventsManager'];

$di->setShared('dispatcher', function() use ($eventsManager) {


$eventsManager->attach('dispatch:beforeExecuteRoute', new \Plugins\Security);
$dispatcher = new \Phalcon\Mvc\Dispatcher;
$dispatcher->setEventsManager($eventsManager);
return $dispatcher;
});

Lea Encargado de eventos en línea: https://riptutorial.com/es/phalcon/topic/5293/encargado-de-


eventos

https://riptutorial.com/es/home 6
Capítulo 3: Enrutamiento y despacho
Examples
Rutas API RESTful para aplicaciones de múltiples módulos

// Define new router group


$api = new \Phalcon\Mvc\Router\Group([
'module' => 'api',
]);
$api->setPrefix('/api/v1');

// API routes (Maps to Cotnroller::Action)


$api->addGet('/users', 'Users::index');
$api->addGet('/users/search/{query}', 'Users::search');
$api->addGet('/users/{id:[0-9]+}', 'Users::fetch');
$api->addPost('/users', 'Users::add');
$api->addPut('/users/{id:[0-9]+}', 'Users::edit');
$api->addDelete('/users/{id:[0-9]+}', 'Users::delete');

// Add API routes to main router


$router->mount($api);

Ejemplo de creación de un usuario:

curl -i -X POST -d
'{"name": "John Snow", "title": "King of the North"}'
http://example.com/api/v1/users

Configurar dinámicamente las rutas del módulo.

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


$router->removeExtraSlashes(true);
$request = new \Phalcon\Http\Request();
$action = strtolower($request->getMethod()); // get, post, etc.
$modules = ['calendar', 'main', 'user']; // names of the modules you create

// you can define other static routes here

foreach ($modules as $module) {


// must match what you register with the Loader service
$namespace = 'App\\' . ucfirst($module) . '\Controllers';

// make a group to avoid setting namespace and module for every route definition
$moduleGroup = new \Phalcon\Mvc\Router\Group([
'namespace' => $namespace,
'module' => $module
]);

// this will match a route like /calendar/index/save


$moduleGroup->add("/{$module}/:controller/:action", [
'controller' => 1,
'action' => 2

https://riptutorial.com/es/home 7
]);

// setting a prefix will apply it to all routes below


$moduleGroup->setPrefix('/api');

// this will match a route like /api/calendar/index/save


$moduleGroup->add("/{$module}/([a-zA-Z_]+)/:action", [
'controller' => 1,
'action' => 2
]);

// this will match a route like /api/calendar/123


$moduleGroup->add("/{$module}/:int", [
'moduleId' => 1,
'controller' => 'index',
'action' => $action // defined at the top of example
]);

$router->mount($moduleGroup);
}

// you can define other static routes here

return $router;

Lea Enrutamiento y despacho en línea: https://riptutorial.com/es/phalcon/topic/5035/enrutamiento-


y-despacho

https://riptutorial.com/es/home 8
Capítulo 4: Filtrado y desinfección
Examples
Conveniente desinfección en el modelo

Establece un método de conveniencia en tu modelo base

namespace Base;

class Model extends \Phalcon\Mvc\Model


{
public function sanitize($attr, $filterName)
{
$filter = $this->getDI()->get('filter');
$this->$attr = $filter->sanitize($this->$attr, $filterName);
}
}

Entonces usa como tal

class User extends \Base\Model


{
public function beforeValidation()
{
$this->sanitize('id', 'int');
// input $this->id: 123abc
// output: 123

$this->sanitize('email', 'email');
// input $this->email: youre(-)mail@dom/ain.com
// output: youremail@domain.com

$this->sanitize('wage', 'float');
// input $this->wage: +1234ab.56cd
// output: 1234.56

$this->sanitize('name', 'string');
// input $this->name: <john>
// output: john
}
}

Lea Filtrado y desinfección en línea: https://riptutorial.com/es/phalcon/topic/4917/filtrado-y-


desinfeccion

https://riptutorial.com/es/home 9
Capítulo 5: Gestión de base de datos
Examples
Usando SQL estándar directamente con modelos

Para usar la sintaxis SQL con el modelo, que transferiría el resultado a las instancias adecuadas,
debe usar directamente una de las clases Phalcon \ Mvc \ Model \ Resultset:

$users = new \Application\Models\Users();

// bitwise operation on `flag` field


$sql = 'SELECT * FROM phorum.users WHERE
(15 & (1 << (flag - 1))) > 0 ORDER BY login DESC';

// as a result you will have a Resultset\Simple with Models\Users instances.


$result = new \Phalcon\Mvc\Model\Resultset\Simple(
null,

// what model to use for data returned from SQL


$users,

// setting result via "read connection" proper for this model.


$users->getReadConnection()->query($sql)
);

Gestión de bases de datos utilizando el modelo Phalcon

Se puede crear un modelo para una nueva tabla ejecutando la siguiente recomendación desde la
ubicación raíz del terminal:

phalcon model <table-name>

Tomemos los Usuarios Modelo.

SELECCIONAR

Hay dos funciones predeterminadas para realizar la operación de selección en phalcon, find() y
findFirst()

se usa para obtener la primera fila que satisface las condiciones que estamos
findFirst()
pasando. Devuelve un solo objeto con los datos en la primera fila.

Ejemplo:

$user = Users::findFirst("active=1 AND verified=1 AND email='a@a.com'");

Esto devuelve al usuario con el correo electrónico dado y el valor de la columna verificado y activo
es 1

https://riptutorial.com/es/home 10
find() se usa para obtener todas las filas que satisfacen las condiciones que estamos pasando.

Ejemplo:

$users = Users::find("active=1 AND verified=1");

Esto devuelve a los usuarios con el valor de la columna verificada y activa es 1

INSERTAR

Insertar se puede hacer utilizando el siguiente código:

$user = new Users();

$user->name = "Arun";
$user->email = "abc@gmail.com";
$user->verified = 1;
$user->active = 1;

$user->save();

Se insertará una nueva fila con estos valores.

ACTUALIZAR

La actualización se puede hacer usando el siguiente código:

Primero tenemos que seleccionar la fila que tenemos que actualizar usando findFirst()

$user = Users::findFirst("email='a@a.com'");

$user->verified = 0;
$user->active = 0;

$user->save();

Esto cambiará los valores de la columna verificada y activa para la fila con el correo electrónico
dado.

ELIMINAR eliminar también se puede hacer usando findFirst ()

Ejemplo:

Users::findFirst("email='a@a.com'")->delete();

Esto eliminará la fila con el correo electrónico dado.

También puede ejecutar comandos SQL personalizados con modelos usando el siguiente código:

$query = $this->modelsManager->createQuery("SELECT * FROM Users WHERE email='a@a.com'");

$user = $query->execute();

https://riptutorial.com/es/home 11
Configuración del servicio de conexión por defecto

Phalcon usa el servicio db por defecto para obtener conexión a las bases de datos.

Suponiendo que tiene un archivo de configuración con un campo de database configurado, puede
incluir o cargar automáticamente el siguiente código para obtener la conexión con la base de
datos para su proyecto:

$di->set('db', function () use ($config) {


$dbconf = $config->database;
switch(strtolower($dbconf->adapter)) {

case 'mysql':
return new \Phalcon\Db\Adapter\Pdo\Mysql(array(
'host' => $dbconf->host,
'username' => $dbconf->username,
'password' => $dbconf->password,
// default database to work with
'dbname' => $dbconf->dbname,
// default character set
'charset' => $dbconf->charset,
// connection warm-up commands for PDO
'options' => array(
PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES "' . $dbconf->charset . '"',
PDO::ATTR_CASE => PDO::CASE_LOWER
)
));

case 'postgresql':
return new \Phalcon\Db\Adapter\Pdo\Postgresql(array(
'host' => $dbconf->host,
'username' => $dbconf->username,
'password' => $dbconf->password,
'dbname' => $dbconf->dbname,
'options' => array(
)
));

default:
throw new \Exception('Unimplemented database::adapter in config.ini');
}
});

Caching Modelos Metadatos.

Phalcon recopila cierta información sobre las tablas que está utilizando, por lo que es posible
validar los datos que se insertan en ellas sin implementar todo a mano. Esos son metadatos para
los modelos. Para acelerar y evitar que Phalcon genere Meta Data cada vez que se actualice la
página, es posible almacenarlos en caché. Para hacerlo, necesita implementar el servicio de
metaData para que lo use:

$di->set('modelsMetadata', function() use ($config)


{
// assuming that you have a $config var with
// models.metadata.adapter field declared

https://riptutorial.com/es/home 12
switch (strtolower($config->models->metadata->adapter)) {
case 'apc':
$metaData = new MetaDataApcAdapter([
'lifetime' => $config->models->metadata->lifetime,
'suffix' => $config->models->metadata->suffix,
]);
break;
case 'xcache':
$metaData = new MetaDataXCacheAdapter([
'lifetime' => $config->models->metadata->lifetime,
'prefix' => $config->models->metadata->suffix,
]);
break;
case 'memory':
$metaData = new MetaDataMemoryAdapter();
break;
default:
throw new \Exception('Unimplemented models::metadata.adapter in config.ini');
}

return $metaData;
});

Más documentación disponible en la página dedicada de Phalcons.

Lea Gestión de base de datos en línea: https://riptutorial.com/es/phalcon/topic/5294/gestion-de-


base-de-datos

https://riptutorial.com/es/home 13
Capítulo 6: Incubadora
Examples
Introducción

La comunidad puede usar la Incubadora Phalcon para experimentar con nuevas funciones o
expandirse a los adaptadores, prototipos o funcionalidades existentes de Phalcon.

Cualquier cosa en la Incubadora puede ser potencialmente corporada en el marco.

Repositorio de Github: https://github.com/phalcon/incubator

Instalación

Instalación vía Composer


La forma más sencilla de instalar la incubadora es mediante el uso de Composer .

Instale Composer y cree un nuevo archivo composer.json en la raíz de su proyecto.

|-- app
|-- public
| `-- index.php
|-- vendor
|-- composer.json

Agregue el siguiente contenido al archivo composer.json . Si todavía está utilizando Phalcon 2.0.x

{
"require": {
"phalcon/incubator": "^2.0"
}
}

Si está utilizando Phalcon 3.0.0

{
"require": {
"phalcon/incubator": "~3.0"
}
}

Después de modificar el archivo composer.json , debe ejecutar el siguiente comando, desde la raíz
de su proyecto.

$ php composer.phar install

https://riptutorial.com/es/home 14
Si ya instaló sus archivos y desea actualizarlos en su lugar. A continuación, utilice la update lugar
de install .
Por defecto, Composer creará una nueva carpeta llamada vendor en la raíz de su proyecto y
descargará todos los archivos solicitados en este directorio.

Después de que se haya instalado el compositor, la estructura de su documento debería verse


así:

|-- app
|-- public
| `-- index.php
|-- vendor
| `-- phalcon
| `-- incubator
| `-- docs
| `-- Library
| `-- tests
|-- composer.json

Instalación vía Github


Cree una carpeta llamada vendor en el directorio raíz de su proyecto. Y también crea la carpeta
phalcon dentro de esta carpeta.

|-- app
|-- public
| `-- index.php
|-- vendor
| `-- phalcon

Ahora navegue dentro de la carpeta phalcon y clone la Incubadora desde el repositorio de Github.

git clone https://github.com/phalcon/incubator.git

De forma predeterminada, el comando anterior descargará la última versión de Phalcon. Si desea


descargar una versión anterior, simplemente puede agregar el parámetro --branch al comando,
seguido de la versión de rama requerida.

git clone https://github.com/phalcon/incubator.git --branch 2.0.9

Instalación vía manual.


Si los métodos anteriores son confusos para usted y le gusta hacer cosas manualmente, puede
descargar fácilmente el repositorio desde Github y colocar los archivos dentro del vendor/phalcon/
, en la raíz de su proyecto.

|-- app

https://riptutorial.com/es/home 15
|-- public
| `-- index.php
|-- vendor
| `-- phalcon

Uso

Cargando la Incubadora en tu proyecto


Agregue las siguientes líneas de código a su archivo de carga

$loader = new Phalcon\Loader();

$loader->registerNamespaces([
'Phalcon' => '/path/to/your/vendor/phalcon/incubator/Library/Phalcon/',
// any other namespaces you have loaded
// ...
]);

$loader->register();

Ahora puede acceder a todas las funcionalidades de la incubadora utilizando los espacios de
nombres normales de Phalcon:

\Phalcon\Acl\Adapter\Database;

Lea Incubadora en línea: https://riptutorial.com/es/phalcon/topic/5354/incubadora

https://riptutorial.com/es/home 16
Capítulo 7: Trabajando con ACL
Sintaxis
• Puede usar '*' como segundo y tercer parámetro en los Phalcon\Acl::allow y
Phalcon\Acl::deny . Esto significará cualquier recurso y acción respectivamente.
• El segundo argumento en Phalcon\Acl::addRole le dice a qué rol de herencia acceso.

Observaciones
• Debería serializar su ACL a algún archivo o respaldo de caché en lugar de crearlo en cada
solicitud.
• También es buena idea mantener la ACL en un archivo separado.
• Phalcon\Acl puede enviar eventos al administrador de eventos, hay dos eventos:
beforeCheckAccess y afterCheckAccess .
• Puede usar Phalcon\Acl\AdapterInterface para implementar su propio adaptador de ACL.
• Puede proteger sus rutas utilizando ACL con la combinación de un oyente adecuado en el
despachador.

Examples
Creando un ACL

Puede crear ACL usando la clase Phalcon\Acl\Adapter\Memory :

$acl = new Phalcon\Acl\Adapter\Memory();

Por defecto, phalcon permite la acción al recurso que no se ha definido, para cambiar esto puede
usar:

$acl->setDefaultAction(Phalcon\Acl::DENY);

Los roles se pueden agregar de dos maneras: usando Phalcon\Acl\Role o simplemente una
cadena simple:

$roleAdministrator = new Phalcon\Acl\Role('Administrator');


$acl->addRole($roleAdministrator);
$acl->addRole('Customer');

Los recursos también se pueden agregar de dos maneras, puede agregar acciones como una
sola acción o como una matriz:

$resourceCategories = new Phalcon\Acl\Resource('categories');


$acl->addResource($resourceCategories, 'create');
$acl->addResource('products', ['create', 'update']);

https://riptutorial.com/es/home 17
Definición de control de acceso y consulta de una ACL

Puede permitir que el rol acceda a alguna acción en el recurso al:

$acl->allow('Administrator', 'products', 'create');

Puede negar el rol para acceder a alguna acción en el recurso mediante:

$acl->deny('Customer', 'categories', 'create');

Puede verificar si el rol está permitido para alguna acción en el recurso utilizando:

$acl->isAllowed('Administrator', 'products', 'create');

Condición adicional en ACL

También puede agregar más lógica que debe verificarse en su ACL mediante funciones
anónimas. Se ejecutarán cuando se use Phalcon\Acl\Adapter\Memory::allow() o
Phalcon\Acl\Adapter\Memory::deny() , si devuelven verdadero, su rol podrá acceder a cierta acción
en el recurso.

$acl->allow('Customer', 'products', 'create', function($parameter) {


return $parameter % 2 == 0;
});
$acl->isAllowed('Customer', 'products', 'create', ['parameter' => 1]); // this will return
false
$acl->isAllowed('Customer', 'products', 'create', ['parameter' => 2]); // this will return
true

Observe cómo se pasan los parámetros a la función. Su clave en la matriz debe tener el mismo
nombre que en la función. También se pueden pasar parámetros de parámetros predeterminados,
así como objetos.

Objetos como roles y recursos.

Al implementar Phalcon\Acl\RoleAware o Phalcon\Acl\ResourceAware , puede usarlos como objetos en


Phalcon\Acl\Adapter\Memory::isAllowed() .

// Create our class which will be used as roleName


class UserRole implements Phalcon\Acl\RoleAware
{
protected $id;
protected $roleName;

public function __construct($id, $roleName)


{
$this->id = $id;
$this->roleName = $roleName;
}

https://riptutorial.com/es/home 18
public function getId()
{
return $this->id;
}

// Implemented function from RoleAware Interface


public function getRoleName()
{
return $this->roleName;
}
}

// Create our class which will be used as resourceName


class ModelResource implements Phalcon\Acl\ResourceAware
{
protected $id;
protected $resourceName;
protected $userId;

public function __construct($id, $resourceName, $userId)


{
$this->id = $id;
$this->resourceName = $resourceName;
$this->userId = $userId;
}

public function getId()


{
return $this->id;
}

public function getUserId()


{
return $this->userId;
}

// Implemented function from ResourceAware Interface


public function getResourceName()
{
return $this->resourceName;
}
}

$customer = new ModelResource(1, "products", 2);


$administrator = new UserRole(1, "Administrator");
$acl->isAllowed($administrator, $customer, 'create');

También la capacidad de usar objetos se puede combinar con una condición adicional en acl:

$acl->allow('Administrator', 'products', 'update', function(UserRole $user, ModelResource


$model) {
return $user->getId == $model->getUserId();
});
$product = new ModelResource(1, 'products', 2);
$administrator = new UserRole(1, 'Administrator');
$anotherAdministrator = new UserRole(2, 'Administrator');
$acl->isAllowed($administrator, $product, 'update'); // this will return false
$acl->isAllowed($anotherAdministrator, $product, 'update'); // this will return true

https://riptutorial.com/es/home 19
Tenga en cuenta que con la condición adicional y el uso de objetos en el método isAllowed , no es
necesario pasar esos objetos como argumentos. Se pasan automáticamente solo si hay tipos
correctos antes de los argumentos en la función. Esto le brinda una gran capacidad de control si
ciertos usuarios pueden editar, por ejemplo, ciertos modelos en su aplicación y cuándo pueden
hacerlo.

Lea Trabajando con ACL en línea: https://riptutorial.com/es/phalcon/topic/5202/trabajando-con-acl

https://riptutorial.com/es/home 20
Capítulo 8: Validación
Observaciones
• La referencia de la API a la clase de validación se puede encontrar aquí:
https://docs.phalconphp.com/en/latest/api/Phalcon_Validation.html
• Si hay una entidad proporcionada en \Phalcon\Validation , no necesita pasar la clave del
modelo en \Phalcon\Validation\Validator\Uniqueness

Examples
Construido en validadores

PresenceOf : valida que un valor no sea nulo o una cadena vacía

$validator->add('name', new \Phalcon\Validation\Validator\PresenceOf([


'message' => 'The name is required'
]));

Correo electrónico : comprueba si un valor tiene un formato de correo electrónico correcto

$validator->add('email', new \Phalcon\Validation\Validator\Email([


'message' => 'The e-mail is not valid'
]));

Idéntico : comprueba si un valor es idéntico a otro

$validator->add('terms', new \Phalcon\Validation\Validator\Identical([


'accepted' => 'yes',
'message' => 'Terms and conditions must be accepted'
]));

Url - Comprueba si un valor tiene un formato de url

$validator->add('url', new \Phalcon\Validation\Validator\Url([


'message' => ':field must be a url'
]));

Confirmación - Comprueba que dos valores tienen el mismo valor

$validator->add('password', new \Phalcon\Validation\Validator\Confirmation([


'message' => 'Password doesn\'t match confirmation',
'with' => 'confirmPassword'
]));

StringLength : valida que una cadena tenga las restricciones máximas y mínimas especificadas.
La prueba se pasa si para la longitud de una cadena L, min <= L <= max, es decir, L debe ser al

https://riptutorial.com/es/home 21
menos min, y como máximo max.

$validation->add('name_last', new \Phalcon\Validation\Validator\StringLength([


'max' => 50,
'min' => 2,
'messageMaximum' => 'We don\'t like really long names',
'messageMinimum' => 'We want more than just their initials'
]));

Regex : permite validar si el valor de un campo coincide con una expresión regular

$validator->add('created_at', new \Phalcon\Validation\Validator\Regex([


'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/',
'message' => 'The creation date is invalid'
]));

Tarjeta de crédito : verifica si un valor tiene un número de tarjeta de crédito válido

$validator->add('creditcard', new \Phalcon\Validation\Validator\CreditCard([


'message' => 'The credit card number is not valid'
]));

Entre : valida que un valor se encuentre entre un rango inclusivo de dos valores. Para un valor x,
la prueba se pasa si mínimo <= x <= máximo.

$validator->add('name', new \Phalcon\Validation\Validator\Between([


'minimum' => 0,
'maximum' => 100,
'message' => 'The price must be between 0 and 100'
]));

ExclusionIn - Comprueba si un valor no está incluido en una lista de valores

$validator->add('status', new \Phalcon\Validation\Validator\ExclusionIn([


'message' => 'The status must not be A or B',
'domain' => ['A', 'B']
]));

InclusionIn - Comprueba si un valor está incluido en una lista de valores

$validator->add('status', new \Phalcon\Validation\Validator\InclusionIn([


'message' => 'The status must be A or B',
'domain' => ['A', 'B']
]));

Unicidad : compruebe si un valor es único.

$validator->add('login', new \Phalcon\Validation\Validator\Uniqueness([


'message' => 'The login must be unique',
'model' => new Users()
]));

https://riptutorial.com/es/home 22
Componente de validación personalizado reCaptcha de Google

La clase

use Phalcon\Validation\Validator;
use Phalcon\Validation\ValidatorInterface;
use Phalcon\Validation\Message;

class RecaptchaValidator extends Validator implements ValidatorInterface


{
public function validate(\Phalcon\Validation $validation, $attribute)
{
$value = $validation->getValue('g-recaptcha-response');
$ip = $validation->request->getClientAddress();
if (!$this->verify($value, $ip)) {
$validation->appendMessage(new Message($this->getOption('message'), $attribute,
'Recaptcha'));
return false;
}
return true;
}

protected function verify($value, $ip)


{
$params = [
'secret' => 'YOUR_RECAPTCHA_SECRET_KEY',
'response' => $value,
'remoteip' => $ip
];
$response =
json_decode(file_get_contents('https://www.google.com/recaptcha/api/siteverify?' .
http_build_query($params)));
return (bool) $response->success;
}
}

Ejemplo de uso en una forma de Phalcon:

$reCaptchaField->addValidator(new \RecaptchaValidator([
'message' => 'Your reCaptcha error message'
]));

Lea Validación en línea: https://riptutorial.com/es/phalcon/topic/4722/validacion

https://riptutorial.com/es/home 23
Creditos
S.
Capítulos Contributors
No

Empezando con 4444, Community, Goke Obasa, Magnie Mozios, Nikolay


1
phalcon Mihaylov, Timothy, yergo

Encargado de
2 galki
eventos

Enrutamiento y
3 galki, Nikolay Mihaylov, Timothy
despacho

Filtrado y
4 galki, Timothy
desinfección

Gestión de base de
5 Arun D Nambissan, yergo
datos

6 Incubadora Timothy

7 Trabajando con ACL Juri

8 Validación Juri, Nikolay Mihaylov, Timothy

https://riptutorial.com/es/home 24