# 教程 4: Using CRUDs
# Tutorial 4: Using CRUDs
Backends usually provides forms to allow users to manipulate data. Continuing the explanation ofINVO, we now address the creation of CRUDs, a very common task that Phalcon will facilitate youusing forms, validations, paginators and more.
### Working with the CRUD
Most options that manipulate data in INVO (companies, products and types of products), were developedusing a basic and common [CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete) (Create, Read, Update and Delete). Each CRUD contains the following files:
```
<pre class="calibre14">```
invo/
app/
controllers/
ProductsController.php
models/
Products.php
forms/
ProductsForm.php
views/
products/
edit.volt
index.volt
new.volt
search.volt
```
```
Each controller has the following actions:
```
<pre class="calibre14">```
<?php
class ProductsController extends ControllerBase
{
/**
* The start action, it shows the "search" view
*/
public function indexAction()
{
// ...
}
/**
* Execute the "search" based on the criteria sent from the "index"
* Returning a paginator for the results
*/
public function searchAction()
{
// ...
}
/**
* Shows the view to create a "new" product
*/
public function newAction()
{
// ...
}
/**
* Shows the view to "edit" an existing product
*/
public function editAction()
{
// ...
}
/**
* Creates a product based on the data entered in the "new" action
*/
public function createAction()
{
// ...
}
/**
* Updates a product based on the data entered in the "edit" action
*/
public function saveAction()
{
// ...
}
/**
* Deletes an existing product
*/
public function deleteAction($id)
{
// ...
}
}
```
```
### The Search Form
Every CRUD starts with a search form. This form shows each field that has the table (products), allowing the userto create a search criteria from any field. Table “products” has a relationship to the table “products\_types”.In this case, we previously queried the records in this table in order to facilitate the search by that field:
```
<pre class="calibre14">```
<?php
/**
* The start action, it shows the "search" view
*/
public function indexAction()
{
$this->persistent->searchParams = null;
$this->view->form = new ProductsForm;
}
```
```
An instance of the form ProductsForm (app/forms/ProductsForm.php) is passed to the view.This form defines the fields that are visible to the user:
```
<pre class="calibre14">```
<?php
use Phalcon\Forms\Form;
use Phalcon\Forms\Element\Text;
use Phalcon\Forms\Element\Hidden;
use Phalcon\Forms\Element\Select;
use Phalcon\Validation\Validator\Email;
use Phalcon\Validation\Validator\PresenceOf;
use Phalcon\Validation\Validator\Numericality;
class ProductsForm extends Form
{
/**
* Initialize the products form
*/
public function initialize($entity = null, $options = array())
{
if (!isset($options['edit'])) {
$element = new Text("id");
$this->add($element->setLabel("Id"));
} else {
$this->add(new Hidden("id"));
}
$name = new Text("name");
$name->setLabel("Name");
$name->setFilters(array('striptags', 'string'));
$name->addValidators(array(
new PresenceOf(array(
'message' => 'Name is required'
))
));
$this->add($name);
$type = new Select('profilesId', ProductTypes::find(), array(
'using' => array('id', 'name'),
'useEmpty' => true,
'emptyText' => '...',
'emptyValue' => ''
));
$this->add($type);
$price = new Text("price");
$price->setLabel("Price");
$price->setFilters(array('float'));
$price->addValidators(array(
new PresenceOf(array(
'message' => 'Price is required'
)),
new Numericality(array(
'message' => 'Price is required'
))
));
$this->add($price);
}
}
```
```
The form is declared using an object-oriented scheme based on the elements provided by the [*forms*](#) component.Every element follows almost the same structure:
```
<pre class="calibre14">```
<?php
// Create the element
$name = new Text("name");
// Set its label
$name->setLabel("Name");
// Before validating the element apply these filters
$name->setFilters(array('striptags', 'string'));
// Apply this validators
$name->addValidators(array(
new PresenceOf(array(
'message' => 'Name is required'
))
));
// Add the element to the form
$this->add($name);
```
```
Other elements are also used in this form:
```
<pre class="calibre14">```
<?php
// Add a hidden input to the form
$this->add(new Hidden("id"));
// ...
// Add a HTML Select (list) to the form
// and fill it with data from "product_types"
$type = new Select('profilesId', ProductTypes::find(), array(
'using' => array('id', 'name'),
'useEmpty' => true,
'emptyText' => '...',
'emptyValue' => ''
));
```
```
Note that ProductTypes::find() contains the data necessary to fill the SELECT tag using Phalcon\\Tag::select.Once the form is passed to the view, it can be rendered and presented to the user:
```
<pre class="calibre14">```
{{ form("products/search") }}
<h2>Search products</h2>
<fieldset>
{% for element in form %}
<div class="control-group">
{{ element.label(['class': 'control-label']) }}
<div class="controls">{{ element }}</div>
</div>
{% endfor %}
<div class="control-group">
{{ submit_button("Search", "class": "btn btn-primary") }}
</div>
</fieldset>
```
```
This produces the following HTML:
```
<pre class="calibre14">```
<form action="/invo/products/search" method="post">
<h2>Search products</h2>
<fieldset>
<div class="control-group">
<label for="id" class="control-label">Id</label>
<div class="controls"><input type="text" id="id" name="id" /></div>
</div>
<div class="control-group">
<label for="name" class="control-label">Name</label>
<div class="controls">
<input type="text" id="name" name="name" />
</div>
</div>
<div class="control-group">
<label for="profilesId" class="control-label">profilesId</label>
<div class="controls">
<select id="profilesId" name="profilesId">
<option value="">...</option>
<option value="1">Vegetables</option>
<option value="2">Fruits</option>
</select>
</div>
</div>
<div class="control-group">
<label for="price" class="control-label">Price</label>
<div class="controls"><input type="text" id="price" name="price" /></div>
</div>
<div class="control-group">
<input type="submit" value="Search" class="btn btn-primary" />
</div>
</fieldset>
```
```
When the form is submitted, the action “search” is executed in the controller performing the searchbased on the data entered by the user.
### Performing a Search
The action “search” has a dual behavior. When accessed via POST, it performs a search based on the data sent from theform. But when accessed via GET it moves the current page in the paginator. To differentiate one from another HTTP method,we check it using the [*Request*](#) component:
```
<pre class="calibre14">```
<?php
/**
* Execute the "search" based on the criteria sent from the "index"
* Returning a paginator for the results
*/
public function searchAction()
{
if ($this->request->isPost()) {
// Create the query conditions
} else {
// Paginate using the existing conditions
}
// ...
}
```
```
With the help of [*Phalcon\\Mvc\\Model\\Criteria*](#), we can create the searchconditions intelligently based on the data types and values sent from the form:
```
<pre class="calibre14">```
<?php
$query = Criteria::fromInput($this->di, "Products", $this->request->getPost());
```
```
This method verifies which values are different from “” (empty string) and null and takes them into account to createthe search criteria:
- If the field data type is text or similar (char, varchar, text, etc.) It uses an SQL “like” operator to filter the results.
- If the data type is not text or similar, it'll use the operator “=”.
Additionally, “Criteria” ignores all the $\_POST variables that do not match any field in the table.Values are automatically escaped using “bound parameters”.
Now, we store the produced parameters in the controller's session bag:
```
<pre class="calibre14">```
<?php
$this->persistent->searchParams = $query->getParams();
```
```
A session bag, is a special attribute in a controller that persists between requests using the session service.When accessed, this attribute injects a [*Phalcon\\Session\\Bag*](#) instancethat is independent in each controller.
Then, based on the built params we perform the query:
```
<pre class="calibre14">```
<?php
$products = Products::find($parameters);
if (count($products) == 0) {
$this->flash->notice("The search did not found any products");
return $this->forward("products/index");
}
```
```
If the search doesn't return any product, we forward the user to the index action again. Let's pretend thesearch returned results, then we create a paginator to navigate easily through them:
```
<pre class="calibre14">```
<?php
use Phalcon\Paginator\Adapter\Model as Paginator;
// ...
$paginator = new Paginator(array(
"data" => $products, // Data to paginate
"limit" => 5, // Rows per page
"page" => $numberPage // Active page
));
// Get active page in the paginator
$page = $paginator->getPaginate();
```
```
Finally we pass the returned page to view:
```
<pre class="calibre14">```
<?php
$this->view->page = $page;
```
```
In the view (app/views/products/search.phtml), we traverse the results corresponding to the current page,showing every row in the current page to the user:
```
<pre class="calibre14">```
{% for product in page.items %}
{% if loop.first %}
<table>
<thead>
<tr>
<th>Id</th>
<th>Product Type</th>
<th>Name</th>
<th>Price</th>
<th>Active</th>
</tr>
</thead>
<tbody>
{% endif %}
<tr>
<td>{{ product.id }}</td>
<td>{{ product.getProductTypes().name }}</td>
<td>{{ product.name }}</td>
<td>{{ "%.2f"|format(product.price) }}</td>
<td>{{ product.getActiveDetail() }}</td>
<td width="7%">{{ link_to("products/edit/" ~ product.id, 'Edit') }}</td>
<td width="7%">{{ link_to("products/delete/" ~ product.id, 'Delete') }}</td>
</tr>
{% if loop.last %}
</tbody>
<tbody>
<tr>
<td colspan="7">
<div>
{{ link_to("products/search", 'First') }}
{{ link_to("products/search?page=" ~ page.before, 'Previous') }}
{{ link_to("products/search?page=" ~ page.next, 'Next') }}
{{ link_to("products/search?page=" ~ page.last, 'Last') }}
<span class="help-inline">{{ page.current }} of {{ page.total_pages }}</span>
</div>
</td>
</tr>
</tbody>
</table>
{% endif %}
{% else %}
No products are recorded
{% endfor %}
```
```
There are many things in the above example that worth detailing. First of all, active itemsin the current page are traversed using a Volt's ‘for'. Volt provides a simpler syntax for a PHP ‘foreach'.
```
<pre class="calibre14">```
{% for product in page.items %}
```
```
Which in PHP is the same as:
```
<pre class="calibre14">```
<?php foreach ($page->items as $product) { ?>
```
```
The whole ‘for' block provides the following:
> {% for product in page.items %}{% if loop.first %}Executed before the first product in the loop{% endif %}Executed for every product of page.items{% if loop.last %}Executed after the last product is loop> {% endif %}
{% else %}Executed if page.items does not have any products> {% endfor %}
Now you can go back to the view and find out what every block is doing. Every fieldin “product” is printed accordingly:
```
<pre class="calibre14">```
<tr>
<td>{{ product.id }}</td>
<td>{{ product.productTypes.name }}</td>
<td>{{ product.name }}</td>
<td>{{ "%.2f"|format(product.price) }}</td>
<td>{{ product.getActiveDetail() }}</td>
<td width="7%">{{ link_to("products/edit/" ~ product.id, 'Edit') }}</td>
<td width="7%">{{ link_to("products/delete/" ~ product.id, 'Delete') }}</td>
</tr>
```
```
As we seen before using [product.id](http://product.id) is the same as in PHP as doing: $product->id,we made the same with [product.name](http://product.name) and so on. Other fields are rendered differently,for instance, let's focus in [product.productTypes.name](http://product.productTypes.name). To understand this part,we have to check the model Products (app/models/Products.php):
```
<pre class="calibre14">```
<?php
use Phalcon\Mvc\Model;
/**
* Products
*/
class Products extends Model
{
// ...
/**
* Products initializer
*/
public function initialize()
{
$this->belongsTo('product_types_id', 'ProductTypes', 'id', array(
'reusable' => true
));
}
// ...
}
```
```
A model, can have a method called “initialize”, this method is called once per request and it servesthe ORM to initialize a model. In this case, “Products” is initialized by defining that this modelhas a one-to-many relationship to another model called “ProductTypes”.
```
<pre class="calibre14">```
<?php
$this->belongsTo('product_types_id', 'ProductTypes', 'id', array(
'reusable' => true
));
```
```
Which means, the local attribute “product\_types\_id” in “Products” has an one-to-many relation tothe model “ProductTypes” in its attribute “id”. By defining this relation we can access the name ofthe product type by using:
```
<pre class="calibre14">```
<td>{{ product.productTypes.name }}</td>
```
```
The field “price” is printed by its formatted using a Volt filter:
```
<pre class="calibre14">```
<td>{{ "%.2f"|format(product.price) }}</td>
```
```
What in PHP would be:
```
<pre class="calibre14">```
<?php echo sprintf("%.2f", $product->price) ?>
```
```
Printing whether the product is active or not uses a helper implemented in the model:
```
<pre class="calibre14">```
<td>{{ product.getActiveDetail() }}</td>
```
```
This method is defined in the model:
### Creating and Updating Records
Now let's see how the CRUD creates and updates records. From the “new” and “edit” views the data entered by the userare sent to the actions “create” and “save” that perform actions of “creating” and “updating” products respectively.
In the creation case, we recover the data submitted and assign them to a new “products” instance:
```
<pre class="calibre14">```
<?php
/**
* Creates a new product
*/
public function createAction()
{
if (!$this->request->isPost()) {
return $this->forward("products/index");
}
$form = new ProductsForm;
$product = new Products();
// ...
}
```
```
Remember the filters we defined in the Products form? Data is filtered before being assigned to the object $product.This filtering is optional, also the ORM escapes the input data and performs additional casting according to the column types:
```
<pre class="calibre14">```
<?php
// ...
$name = new Text("name");
$name->setLabel("Name");
// Filters for name
$name->setFilters(array('striptags', 'string'));
// Validators for name
$name->addValidators(array(
new PresenceOf(array(
'message' => 'Name is required'
))
));
$this->add($name);
```
```
When saving we'll know whether the data conforms to the business rules and validations implementedin the form ProductsForm (app/forms/ProductsForm.php):
```
<pre class="calibre14">```
<?php
// ...
$form = new ProductsForm;
$product = new Products();
// Validate the input
$data = $this->request->getPost();
if (!$form->isValid($data, $product)) {
foreach ($form->getMessages() as $message) {
$this->flash->error($message);
}
return $this->forward('products/new');
}
```
```
Finally, if the form does not return any validation message we can save the product instance:
```
<pre class="calibre14">```
<?php
// ...
if ($product->save() == false) {
foreach ($product->getMessages() as $message) {
$this->flash->error($message);
}
return $this->forward('products/new');
}
$form->clear();
$this->flash->success("Product was created successfully");
return $this->forward("products/index");
```
```
Now, in the case of product updating, first we must present to the user the data that is currently in the edited record:
```
<pre class="calibre14">```
<?php
/**
* Edits a product based on its id
*/
public function editAction($id)
{
if (!$this->request->isPost()) {
$product = Products::findFirstById($id);
if (!$product) {
$this->flash->error("Product was not found");
return $this->forward("products/index");
}
$this->view->form = new ProductsForm($product, array('edit' => true));
}
}
```
```
The data found is bound to the form passing the model as first parameter. Thanks to this,the user can change any value and then sent it back to the database through to the “save” action:
```
<pre class="calibre14">```
<?php
/**
* Saves current product in screen
*
* @param string $id
*/
public function saveAction()
{
if (!$this->request->isPost()) {
return $this->forward("products/index");
}
$id = $this->request->getPost("id", "int");
$product = Products::findFirstById($id);
if (!$product) {
$this->flash->error("Product does not exist");
return $this->forward("products/index");
}
$form = new ProductsForm;
$data = $this->request->getPost();
if (!$form->isValid($data, $product)) {
foreach ($form->getMessages() as $message) {
$this->flash->error($message);
}
return $this->forward('products/new');
}
if ($product->save() == false) {
foreach ($product->getMessages() as $message) {
$this->flash->error($message);
}
return $this->forward('products/new');
}
$form->clear();
$this->flash->success("Product was updated successfully");
return $this->forward("products/index");
}
```
```
We have seen how Phalcon lets you create forms and bind data from a database in a structured [way.In](http://way.In) next chapter, we will see how to add custom HTML elements like a menu.
|
- [索引](# "总目录")
- [下一页](# "Tutorial 5: Customizing INVO") |
- [上一页](# "Tutorial 3: Securing INVO") |
- API参考
- API列表
- Abstract class Phalcon\Acl
- Abstract class Phalcon\Acl\Adapter
- Class Phalcon\Acl\Adapter\Memory
- Interface Phalcon\Acl\AdapterInterface
- Class Phalcon\Acl\Exception
- Class Phalcon\Acl\Resource
- Interface Phalcon\Acl\ResourceInterface
- Class Phalcon\Acl\Role
- Interface Phalcon\Acl\RoleInterface
- Class Phalcon\Annotations\Annotation
- Abstract class Phalcon\Annotations\Adapter
- Interface Phalcon\Annotations\AdapterInterface
- Class Phalcon\Annotations\Collection
- Class Phalcon\Annotations\Exception
- Class Phalcon\Annotations\Reader
- Interface Phalcon\Annotations\ReaderInterface
- Class Phalcon\Annotations\Reflection
- Class Phalcon\Assets\Collection
- Class Phalcon\Assets\Exception
- Interface Phalcon\Assets\FilterInterface
- Class Phalcon\Assets\Filters\Cssmin
- Class Phalcon\Assets\Filters\Jsmin
- Class Phalcon\Assets\Filters\None
- Class Phalcon\Assets\Inline
- Class Phalcon\Assets\Inline\Css
- Class Phalcon\Assets\Inline\Js
- Class Phalcon\Assets\Manager
- Class Phalcon\Assets\Resource
- Class Phalcon\Assets\Resource\Css
- Class Phalcon\Assets\Resource\Js
- Abstract class Phalcon\Cache\Backend
- Class Phalcon\Cache\Backend\Apc
- Class Phalcon\Cache\Backend\File
- Class Phalcon\Cache\Backend\Libmemcached
- Class Phalcon\Cache\Backend\Memcache
- Class Phalcon\Cache\Backend\Memory
- Class Phalcon\Cache\Backend\Mongo
- Class Phalcon\Cache\Backend\Redis
- Class Phalcon\Cache\Backend\Xcache
- Interface Phalcon\Cache\BackendInterface
- Class Phalcon\Cache\Exception
- Class Phalcon\Cache\Frontend\Base64
- Class Phalcon\Cache\Frontend\Data
- Class Phalcon\Cache\Frontend\Igbinary
- Class Phalcon\Cache\Frontend\Json
- Class Phalcon\Cache\Frontend\None
- Class Phalcon\Cache\Frontend\Output
- Interface Phalcon\Cache\FrontendInterface
- Class Phalcon\Cache\Multiple
- Class Phalcon\Cli\Router\Route
- Class Phalcon\Config
- Class Phalcon\Config\Adapter\Ini
- Class Phalcon\Config\Adapter\Json
- Class Phalcon\Config\Adapter\Php
- Class Phalcon\Config\Adapter\Yaml
- Class Phalcon\Config\Exception
- Class Phalcon\Crypt
- Class Phalcon\Crypt\Exception
- Interface Phalcon\CryptInterface
- Abstract class Phalcon\Db
- Abstract class Phalcon\Db\Adapter
- Interface Phalcon\Db\AdapterInterface
- Class Phalcon\Db\Column
- Interface Phalcon\Db\ColumnInterface
- Abstract class Phalcon\Db\Dialect
- Interface Phalcon\Db\DialectInterface
- Class Phalcon\Db\Exception
- Class Phalcon\Db\Index
- Interface Phalcon\Db\IndexInterface
- Class Phalcon\Db\Profiler
- Class Phalcon\Db\RawValue
- Class Phalcon\Db\Reference
- Interface Phalcon\Db\ReferenceInterface
- Class Phalcon\Db\Result\Pdo
- Interface Phalcon\Db\ResultInterface
- Class Phalcon\Debug
- Class Phalcon\Debug\Dump
- Class Phalcon\Debug\Exception
- Interface Phalcon\DiInterface
- Abstract class Phalcon\Dispatcher
- Interface Phalcon\DispatcherInterface
- Class Phalcon\Escaper
- Class Phalcon\Escaper\Exception
- Interface Phalcon\EscaperInterface
- Class Phalcon\Events\Event
- Interface Phalcon\Events\EventsAwareInterface
- Class Phalcon\Events\Exception
- Class Phalcon\Events\Manager
- Interface Phalcon\Events\ManagerInterface
- Class Phalcon\Exception
- Class Phalcon\Filter
- Class Phalcon\Filter\Exception
- Interface Phalcon\Filter\UserFilterInterface
- Interface Phalcon\FilterInterface
- Abstract class Phalcon\Flash
- Class Phalcon\Flash\Direct
- Class Phalcon\Flash\Exception
- Class Phalcon\Flash\Session
- Interface Phalcon\FlashInterface
- Class Phalcon\Forms\Form
- Abstract class Phalcon\Forms\Element
- Class Phalcon\Forms\Exception
- Class Phalcon\Forms\Manager
- Class Phalcon\Http\Cookie
- Class Phalcon\Http\Cookie\Exception
- Class Phalcon\Http\Request
- Class Phalcon\Http\Request\Exception
- Class Phalcon\Http\Request\File
- Interface Phalcon\Http\Request\FileInterface
- Interface Phalcon\Http\RequestInterface
- Class Phalcon\Http\Response
- Class Phalcon\Http\Response\Cookies
- Interface Phalcon\Http\Response\CookiesInterface
- Class Phalcon\Http\Response\Exception
- Class Phalcon\Http\Response\Headers
- Interface Phalcon\Http\Response\HeadersInterface
- Interface Phalcon\Http\ResponseInterface
- Class Phalcon\Image
- Abstract class Phalcon\Image\Adapter
- Class Phalcon\Image\Adapter\Imagick
- Interface Phalcon\Image\AdapterInterface
- Class Phalcon\Image\Exception
- Class Phalcon\Kernel
- Class Phalcon\Loader
- Class Phalcon\Loader\Exception
- Abstract class Phalcon\Logger
- Abstract class Phalcon\Logger\Adapter
- Class Phalcon\Logger\Adapter\File
- Class Phalcon\Logger\Adapter\Firephp
- Class Phalcon\Logger\Adapter\Stream
- Class Phalcon\Logger\Adapter\Syslog
- Interface Phalcon\Logger\AdapterInterface
- Class Phalcon\Logger\Exception
- Abstract class Phalcon\Logger\Formatter
- Interface Phalcon\Logger\FormatterInterface
- Class Phalcon\Logger\Item
- Class Phalcon\Logger\Multiple
- Class Phalcon\Mvc\Application
- Class Phalcon\Mvc\Application\Exception
- Abstract class Phalcon\Mvc\Collection
- Abstract class Phalcon\Mvc\Collection\Behavior
- Class Phalcon\Mvc\Collection\Behavior\SoftDelete
- Class Phalcon\Mvc\Collection\Behavior\Timestampable
- Interface Phalcon\Mvc\Collection\BehaviorInterface
- Class Phalcon\Mvc\Collection\Document
- Class Phalcon\Mvc\Collection\Exception
- Class Phalcon\Mvc\Collection\Manager
- Interface Phalcon\Mvc\Collection\ManagerInterface
- Interface Phalcon\Mvc\CollectionInterface
- Abstract class Phalcon\Mvc\Controller
- Interface Phalcon\Mvc\ControllerInterface
- Class Phalcon\Mvc\Dispatcher
- Class Phalcon\Mvc\Dispatcher\Exception
- Interface Phalcon\Mvc\DispatcherInterface
- Interface Phalcon\Mvc\EntityInterface
- Class Phalcon\Mvc\Micro
- Class Phalcon\Mvc\Micro\Collection
- Interface Phalcon\Mvc\Micro\CollectionInterface
- Class Phalcon\Mvc\Micro\Exception
- Class Phalcon\Mvc\Micro\LazyLoader
- Interface Phalcon\Mvc\Micro\MiddlewareInterface
- Abstract class Phalcon\Mvc\Model
- Abstract class Phalcon\Mvc\Model\Behavior
- Class Phalcon\Mvc\Model\Criteria
- Interface Phalcon\Mvc\Model\CriteriaInterface
- Class Phalcon\Mvc\Model\Exception
- Class Phalcon\Mvc\Model\Manager
- Interface Phalcon\Mvc\Model\ManagerInterface
- Class Phalcon\Mvc\Model\Message
- Interface Phalcon\Mvc\Model\MessageInterface
- Abstract class Phalcon\Mvc\Model\MetaData
- Interface Phalcon\Mvc\Model\MetaDataInterface
- Class Phalcon\Mvc\Model\Query
- Interface Phalcon\Mvc\Model\QueryInterface
- Class Phalcon\Mvc\Model\Relation
- Interface Phalcon\Mvc\Model\RelationInterface
- Interface Phalcon\Mvc\Model\ResultInterface
- Abstract class Phalcon\Mvc\Model\Resultset
- Abstract class Phalcon\Mvc\Model\Validator
- Interface Phalcon\Mvc\Model\ResultsetInterface
- Class Phalcon\Mvc\Model\Row
- Class Phalcon\Mvc\Model\Transaction
- Interface Phalcon\Mvc\Model\TransactionInterface
- Class Phalcon\Mvc\Model\ValidationFailed
- Interface Phalcon\Mvc\ModelInterface
- Interface Phalcon\Mvc\ModuleDefinitionInterface
- Class Phalcon\Mvc\Router
- Class Phalcon\Mvc\Router\Annotations
- Class Phalcon\Mvc\Router\Exception
- Class Phalcon\Mvc\Router\Group
- Interface Phalcon\Mvc\Router\GroupInterface
- Class Phalcon\Mvc\Router\Route
- Interface Phalcon\Mvc\Router\RouteInterface
- Interface Phalcon\Mvc\RouterInterface
- Class Phalcon\Mvc\Url
- Class Phalcon\Mvc\Url\Exception
- Interface Phalcon\Mvc\UrlInterface
- Class Phalcon\Mvc\User\Component
- Class Phalcon\Mvc\User\Module
- Class Phalcon\Mvc\User\Plugin
- Class Phalcon\Mvc\View
- Abstract class Phalcon\Mvc\View\Engine
- Interface Phalcon\Mvc\View\EngineInterface
- Class Phalcon\Mvc\View\Exception
- Class Phalcon\Mvc\View\Simple
- Interface Phalcon\Mvc\ViewBaseInterface
- Interface Phalcon\Mvc\ViewInterface
- Abstract class Phalcon\Paginator\Adapter
- Class Phalcon\Paginator\Adapter\Model
- Class Phalcon\Paginator\Adapter\NativeArray
- Class Phalcon\Paginator\Adapter\QueryBuilder
- Interface Phalcon\Paginator\AdapterInterface
- Class Phalcon\Paginator\Exception
- Class Phalcon\Queue\Beanstalk
- Class Phalcon\Queue\Beanstalk\Job
- Final class Phalcon\Registry
- Class Phalcon\Security
- Class Phalcon\Security\Exception
- Abstract class Phalcon\Session
- Abstract class Phalcon\Session\Adapter
- Interface Phalcon\Session\AdapterInterface
- Class Phalcon\Session\Bag
- Interface Phalcon\Session\BagInterface
- Class Phalcon\Session\Exception
- Class Phalcon\Tag
- Class Phalcon\Tag\Exception
- Abstract class Phalcon\Tag\Select
- Abstract class Phalcon\Text
- Abstract class Phalcon\Translate
- Abstract class Phalcon\Translate\Adapter
- Class Phalcon\Translate\Adapter\Csv
- Class Phalcon\Translate\Adapter\Gettext
- Class Phalcon\Translate\Adapter\NativeArray
- Interface Phalcon\Translate\AdapterInterface
- Class Phalcon\Translate\Exception
- Class Phalcon\Validation
- Class Phalcon\Validation\Exception
- Class Phalcon\Validation\Message
- Class Phalcon\Validation\Message\Group
- Interface Phalcon\Validation\MessageInterface
- Abstract class Phalcon\Validation\Validator
- Class Phalcon\Validation\Validator\Alnum
- Class Phalcon\Validation\Validator\Alpha
- Class Phalcon\Validation\Validator\Between
- Class Phalcon\Validation\Validator\Confirmation
- Class Phalcon\Validation\Validator\Digit
- Class Phalcon\Validation\Validator\Email
- Class Phalcon\Validation\Validator\ExclusionIn
- Class Phalcon\Validation\Validator\File
- Class Phalcon\Validation\Validator\Identical
- Class Phalcon\Validation\Validator\InclusionIn
- Class Phalcon\Validation\Validator\Numericality
- Class Phalcon\Validation\Validator\PresenceOf
- Class Phalcon\Validation\Validator\Regex
- Class Phalcon\Validation\Validator\StringLength
- Class Phalcon\Validation\Validator\Uniqueness
- Class Phalcon\Validation\Validator\Url
- Interface Phalcon\Validation\ValidatorInterface
- Class Phalcon\Version
- 参考手册
- 安装（Installation）
- 教程 1：让我们通过例子来学习（Tutorial 1: Let’s learn by example）
- 教程 2：Introducing INVO（Tutorial 2: Introducing INVO）
- 教程 3: Securing INVO
- 教程 4: Using CRUDs
- 教程 5: Customizing INVO
- 教程 6: Vkuró
- 教程 7：创建简单的 REST API（Tutorial 7: Creating a Simple REST API）
- 示例列表（List of examples）
- 依赖注入与服务定位器（Dependency Injection/Service Location）
- MVC 架构（The MVC Architecture）
- 使用控制器（Using Controllers）
- 使用模型（Working with Models）
- 模型元数据（Models Meta-Data）
- 事务管理（Model Transactions）
- Phalcon 查询语言（Phalcon Query Language (PHQL)）
- 缓存对象关系映射（Caching in the ORM）
- 对象文档映射 ODM (Object-Document Mapper)
- 使用视图（Using Views）
- 视图助手（View Helpers）
- 资源文件管理（Assets Management）
- Volt 模版引擎（Volt: Template Engine）
- MVC 应用（MVC Applications）
- 路由（Routing）
- 调度控制器（Dispatching Controllers）
- 微应用（Micro Applications）
- 使用命名空间（Working with Namespaces）
- 事件管理器（Events Manager）
- Request Environment
- 返回响应（Returning Responses）
- Cookie 管理（Cookies Management）
- 生成 URL 和 路径（Generating URLs and Paths）
- 闪存消息（Flashing Messages）
- 使用 Session 存储数据（Storing data in Session）
- 过滤与清理（Filtering and Sanitizing）
- 上下文编码（Contextual Escaping）
- 验证（Validation）
- 表单（Forms）
- 读取配置（Reading Configurations）
- 分页（Pagination）
- 使用缓存提高性能（Improving Performance with Cache）
- 安全（Security）
- Encryption/Decryption
- 访问控制列表 ACL（Access Control Lists ACL）
- 多语言支持（Multi-lingual Support）
- Universal Class Loader
- 日志记录（Logging）
- 注释解析器（Annotations Parser）
- 命令行应用（Command Line Applications）
- 队列（Queueing）
- 数据库抽象层（Database Abstraction Layer）
- 国际化（Internationalization）
- 数据库迁移（Database Migrations）
- 调试应用程序（Debugging Applications）
- Phalcon 开发工具（Phalcon Developer Tools）
- 提高性能：下一步该做什么？（Increasing Performance: What’s next?）
- 单元测试（Unit testing）
- 授权（License）