Estas herramientas le ayudarán a generar código esqueleto, a mantener su estructura de base de datos y a acelerar el desarrollo. Los componentes principales de su aplicación se pueden generar con un comando simple, permitiéndole desarrollar aplicaciones fácilmente usando Phalcon.
Las Devtool de Phalcon se pueden controlar usando la línea de comandos o el interfaz web.
Se pueden instalar las Devtools de Phalcon usando
Instalar las Devtools de Phalcon globalmente
English (US)
Czech
German
Greek
Persian
French
Indonesian
Italian
Korean
Japanese
Mongolian
Dutch
Polish
Portuguese, Brazilian
Russian
Serbian (Cyrillic)
Thai
Turkish
Ukrainian
Chinese Simplifiedcomposer global require phalcon/devtools
O sólo en su proyecto
composer require phalcon/devtools
Compruebe su instalación escribiendo: phalcon
$ phalcon
Phalcon DevTools (4.0.0)
Available commands:
info (alias of: i)
commands (alias of: list, enumerate)
controller (alias of: create-controller)
module (alias of: create-module)
model (alias of: create-model)
all-models (alias of: create-all-models)
project (alias of: create-project)
scaffold (alias of: create-scaffold)
migration (alias of: create-migration)
webtools (alias of: create-webtools)
serve (alias of: server)
console (alias of: shell, psysh)
Las devtools también están disponibles como descarga phar en nuestro repositorio git.
Puede obtener un listado de los comandos disponibles en las herramientas Phalcon escribiendo: phalcon commands
$ phalcon commands
Phalcon DevTools (4.0.0)
Available commands:
info (alias of: i)
commands (alias of: list, enumerate)
controller (alias of: create-controller)
module (alias of: create-module)
model (alias of: create-model)
all-models (alias of: create-all-models)
project (alias of: create-project)
scaffold (alias of: create-scaffold)
migration (alias of: create-migration)
webtools (alias of: create-webtools)
serve (alias of: server)
console (alias of: shell, psysh)
Puede usar las herramientas de Phalcon para generar esqueletos de proyecto predefinidos para sus aplicaciones con el framework Phalcon. Por defecto el generador de esqueletos de proyecto usarán mod_rewrite de Apache. Escriba el siguiente comando en el document root de su servidor web:
$ phalcon create-project store
Se generó la estructura de proyecto recomendada anterior:
Podría añadir el parámetro --help para obtener ayuda sobre el uso de un comando específico:
$ phalcon project --help
Phalcon DevTools (4.0.0)
Help:
Creates a project
Usage:
project [name] [type] [directory] [enable-webtools]
Arguments:
help Shows this help text
Example
phalcon project store simple
Options:
--name=s Name of the new project
--enable-webtools Determines if webtools should be enabled [optional]
--directory=s Base path on which project will be created [optional]
--type=s Type of the application to be generated (cli, micro, simple, modules)
--template-path=s Specify a template path [optional]
--template-engine=s Define the template engine, default phtml (phtml, volt) [optional]
--use-config-ini Use a ini file as configuration file [optional]
--trace Shows the trace of the framework in case of exception [optional]
--help Shows this help [optional]
Acceder al proyecto desde el servidor web le mostrará:
El comando create-controller genera estructuras esqueleto de controlador. Es importante invocar este comando dentro de un directorio que ya tenga un proyecto Phalcon.
$ phalcon create-controller --name test
Se genera el siguiente código por el script:
<?php
declare(strict_types=1);
class TestController extends \Phalcon\Mvc\Controller
{
public function indexAction()
{
}
}
Cuando se genera un proyecto usando las herramientas de desarrollo. Se puede encontrar un fichero de configuración en app/config/config.php. Para generar modelos o andamios, necesitará cambiar los ajustes usados para conectar con su base de datos.
Cambie la sección de base de datos de su fichero config.php:
<?php
/*
* Modified: prepend 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' => '/',
]
]);
Hay varias maneras de crear modelos. Puede crear todos los modelos de la conexión de base de datos por defecto o algunos específicamente. Los modelos pueden tener atributos públicos como representación de los campos o se pueden usar setters/getters.
Opciones:
--name=s Nombre de la tabla
--schema=s Nombre del esquema [optional]
--config=s Fichero de configuración [optional]
--namespace=s Espacio de nombres del modelo [optional]
--get-set Los atributos serán <em>protected</em> y tendrán <em>setters</em>/<em>getters</em> [optional]
--extends=s El modelo extenderá el nombre de clase proporcionado [optional]
--excludefields=l Excluye los campos definidos en una lista separada por comas [optional]
--doc Ayuda a mejorar el completado de código en IDEs [optional]
--directory=s Ruta base en la que el proyecto se aloja [optional]
--output=s Carpeta donde residen los modelos [optional]
--force Reescribir el modelo [optional]
--camelize Las propiedades están en camelCase [optional]
--trace Muestra la traza del framework en caso de excepción [optional]
--mapcolumn Obtiene algo de código para el mapeado de columnas [optional]
--abstract Modelo <em>Abstract</em> [optional]
--annotate Anotaciones de Atributos [optional]
--help Muestra esta ayuda [optional]
La manera más simple de generar un modelo para una tabla llamada users es:
$ phalcon model users
Si su base de datos se ve así:
CREATE TABLE `users` (
`id` int(10) UNSIGNED NOT NULL,
`name` varchar(255) NOT NULL,
`email` varchar(255) NOT NULL,
`password` char(60) NOT NULL,
`active` tinyint(1) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
ALTER TABLE `users`
ADD PRIMARY KEY (`id`),
ADD KEY `email` (`email`);
ALTER TABLE `users`
MODIFY `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT;
COMMIT;
Resultará en
<?php
use Phalcon\Validation;
use Phalcon\Validation\Validator\Email as EmailValidator;
class Users extends \Phalcon\Mvc\Model
{
/**
*
* @var integer
*/
public $id;
/**
*
* @var string
*/
public $name;
/**
*
* @var string
*/
public $email;
/**
*
* @var string
*/
public $password;
/**
*
* @var string
*/
public $active;
/**
* Validations and business logic
*
* @return boolean
*/
public function validation()
{
$validator = new Validation();
$validator->add(
'email',
new EmailValidator(
[
'model' => $this,
'message' => 'Please enter a correct email address',
]
)
);
return $this->validate($validator);
}
/**
* Initialize method for model.
*/
public function initialize()
{
$this->setSchema("test");
$this->setSource("users");
}
/**
* Allows to query a set of records that match the specified conditions
*
* @param mixed $parameters
* @return Users[]|Users|\Phalcon\Mvc\Model\ResultSetInterface
*/
public static function find($parameters = null): \Phalcon\Mvc\Model\ResultsetInterface
{
return parent::find($parameters);
}
/**
* Allows to query the first record that match the specified conditions
*
* @param mixed $parameters
* @return Users|\Phalcon\Mvc\Model\ResultInterface
*/
public static function findFirst($parameters = null)
{
return parent::findFirst($parameters);
}
}
Opciones para generar diferentes tipos de formatos de modelo se pueden encontrar usando
phalcon model --help
El scaffolding o andamiaje es una forma rápida de generar algunas de las piezas principales de una aplicación. Si quiere crear modelos, vistas y controladores para un nuevo recurso en una sola operación, el andamiaje es la herramienta para este trabajo.
Una vez se genera el código, debe adaptarlo para cumplir con sus necesidades. Muchos desarrolladores evitan completamente el andamiaje, optando por escribir todo o la mayoría de su código fuente desde cero. El código generado puede servir como guía para comprender mejor cómo trabaja el framework o los prototipos de desarrollo. El siguiente código muestra un andamio basado en la tabla users:
$ phalcon scaffold --table-name users
El generador del andamio construirá varios ficheros en su aplicación, además de algunas carpetas. Aquí hay un resumen breve de lo que se generará:
| Archivo | Propósito |
|---|---|
app/controllers/UsersController.php |
El controlador de Usuarios |
app/models/Users.php |
El modelo de Usuarios |
app/views/layout/users.phtml |
Disposición de la vista de Usuarios |
app/views/products/search.phtml |
Vista para la acción search |
app/views/products/new.phtml |
Vista para la acción new |
app/views/products/edit.phtml |
View for the action edit |
Si navega por el controlador recién generado, verá un formulario de búsqueda y un link para crear un nuevo Usuario:
El create page le permite crear usuarios aplicando validaciones sobre el modelo Usuarios. Phalcon automáticamente validará campos no nulos produciendo avisos si se requiere.
Después de realizar una búsqueda, hay un componente de paginado disponible para mostrar los resultados paginados. Use los enlaces “Edit” (Editar) or “Delete” (Borrar) delante de cada resultado para ejecutar esas acciones.
También, si lo prefiere, es posible usar las Herramientas de Desarrollo de Phalcon desde un interfaz web. Eche un vistazo al siguiente videotutorial para descubrir como funciona:
El siguiente videotutorial muestra como integrar las herramientas de desarrollo con el IDE PhpStorm. Los pasos de configuración podrían adaptarse fácilmente a otros IDEs para PHP.