php/yii2
1
0
Fork 0
mirror of https://github.com/yiisoft/yii2.git synced 2025-08-14 14:28:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

Updates pt-BR translation (#17105) [skip ci]

Browse Source
This commit is contained in:
Sidney Lins
2019-02-06 07:37:48 -02:00
committed by Alexander Makarov
parent c776cf6240
commit fe3ae964cd
14 changed files with 387 additions and 455 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
docs/guide-pt-BR/README.md
View File

@ -21,7 +21,7 @@ Primeiros Passos
* [O que você precisa saber](start-prerequisites.md)
* [Instalando o Yii](start-installation.md)
* [Executando Aplicações](start-workflow.md)
* [Fazendo um Hello-World](start-hello.md)
* [Dizendo "Olá!"](start-hello.md)
* [Trabalhando com Formulários](start-forms.md)
* [Trabalhando com Bancos de Dados](start-databases.md)
* [Gerando Código com Gii](start-gii.md)

BIN
docs/guide-pt-BR/images/start-country-list.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 49 KiB

After

Width:  |  Height:  |  Size: 40 KiB

BIN
docs/guide-pt-BR/images/start-entry-confirmation.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 39 KiB

After

Width:  |  Height:  |  Size: 35 KiB

BIN
docs/guide-pt-BR/images/start-form-validation.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 39 KiB

After

Width:  |  Height:  |  Size: 36 KiB

BIN
docs/guide-pt-BR/images/start-gii-country-grid.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 84 KiB

After

Width:  |  Height:  |  Size: 81 KiB

BIN
docs/guide-pt-BR/images/start-gii-country-update.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 53 KiB

After

Width:  |  Height:  |  Size: 45 KiB

BIN
docs/guide-pt-BR/images/start-hello-world.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 32 KiB

After

Width:  |  Height:  |  Size: 29 KiB

229
docs/guide-pt-BR/start-databases.md
View File

@ -1,102 +1,101 @@
Trabalhando com Bancos de Dados
===============================
Esta seção descreverá como criar uma nova página que exibe dados de países
buscados de uma tabela do banco de dados chamada `country`. Para isso, você
Esta seção descreverá como criar uma nova página que exibe informações de países obtidos de uma tabela de banco de dados chamada `pais`. Para isso, você
configurará uma conexão com o banco de dados, criará uma classe de
[Active Record](db-active-record.md), definirá uma [action](structure-controllers.md) (ação),
e criará uma [view](structure-views.md) (visão).
[Active Record](db-active-record.md), definirá uma [action](structure-controllers.md) e criará uma [view](structure-views.md).
Através deste tutorial, você aprenderá como:
Ao longo deste tutorial, você aprenderá como:
* Configurar uma conexão de BD
* Definir uma classe de Active Record
* Consultar dados usando a classe de Active Record
* Exibir dados em uma view de forma paginada
* configurar uma conexão de BD
* definir uma classe Active Record
* consultar dados usando a classe de Active Record
* exibir dados em uma view de forma paginada
Perceba que para terminar essa seção, você deve ter conhecimento e experiência
básica usando bancos de dados. Em particular, você deveria saber como criar um
banco de dados, e como executar instruções SQL usando uma ferramenta de cliente
de BD.
básicos em bancos de dados. Em particular, você deve saber como criar um banco de dados e como executar instruções SQL usando uma ferramenta cliente de bancos de dados.
Preparando o Banco de Dados <span id="preparing-database"></span>
---------------------------
Para começar, crie um banco de dados chamado `yii2basic`, a partir do qual você
buscará os dados em sua aplicação. Você pode criar um banco de dados SQLite, MySQL,
PostgreSQL, MSSQL ou Oracle, já que o Yii tem suporte embutido a muitas aplicações
de bancos de dados. Por questões de simplicidade, será assumido o uso do MySQL
Para começar, crie um banco de dados chamado `yii2basico`, de onde você
obterá os dados em sua aplicação. Você pode criar um banco de dados SQLite, MySQL,
PostgreSQL, MSSQL ou Oracle, já que o Yii tem suporte embutido a vários gerenciadores de bancos de dados. Por questões de simplicidade, será assumido o uso do MySQL
na descrição a seguir.
Em seguida, crie uma tabela chamada `country` no banco de dados, e insira alguns
dados de exemplo. Você pode rodar as seguintes declarações SQL para fazê-lo:
> Info: O MariaDB costumava ser um substituto transparente do MySQL. Isto já não é mais totalmente verdade. Caso você queira usar recursos avançados como suporte a `JSON` no MariaDB, por favor, consulte a extensão do MariaDB listada mais à frente.
Em seguida, crie uma tabela chamada `pais` no banco de dados e insira alguns
dados de exemplo. Você pode rodar as seguintes declarações SQL para fazer isso:
```sql
CREATE TABLE `country` (
`code` CHAR(2) NOT NULL PRIMARY KEY,
`name` CHAR(52) NOT NULL,
`population` INT(11) NOT NULL DEFAULT '0'
CREATE TABLE `pais` (
`codigo` CHAR(2) NOT NULL PRIMARY KEY,
`nome` CHAR(52) NOT NULL,
`populacao` INT(11) NOT NULL DEFAULT '0'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO `country` VALUES ('AU','Australia',24016400);
INSERT INTO `country` VALUES ('BR','Brazil',205722000);
INSERT INTO `country` VALUES ('CA','Canada',35985751);
INSERT INTO `country` VALUES ('CN','China',1375210000);
INSERT INTO `country` VALUES ('DE','Germany',81459000);
INSERT INTO `country` VALUES ('FR','France',64513242);
INSERT INTO `country` VALUES ('GB','United Kingdom',65097000);
INSERT INTO `country` VALUES ('IN','India',1285400000);
INSERT INTO `country` VALUES ('RU','Russia',146519759);
INSERT INTO `country` VALUES ('US','United States',322976000);
INSERT INTO `pais` VALUES ('AU','Austrália',24016400);
INSERT INTO `pais` VALUES ('BR','Brasil',205722000);
INSERT INTO `pais` VALUES ('CA','Canadá',35985751);
INSERT INTO `pais` VALUES ('CN','China',1375210000);
INSERT INTO `pais` VALUES ('DE','Alemanha',81459000);
INSERT INTO `pais` VALUES ('FR','França',64513242);
INSERT INTO `pais` VALUES ('GB','Reino Unido',65097000);
INSERT INTO `pais` VALUES ('IN','Índia',1285400000);
INSERT INTO `pais` VALUES ('RU','Rússia',146519759);
INSERT INTO `pais` VALUES ('US','Estados Unidos',322976000);
```
Neste ponto, você tem um banco de dados chamado `yii2basic`, e dentro dele uma
tabela `country` com três colunas, contendo dez linhas de dados.
Neste ponto, você tem um banco de dados chamado `yii2basico` e dentro dele uma
tabela `pais` com três colunas, contendo dez linhas de dados.
Configurando uma Conexão do BD <span id="configuring-db-connection"></span>
Configurando uma Conexão de BD <span id="configuring-db-connection"></span>
------------------------------
Antes de prosseguir, certifique-se de que você possui instalados tanto a
extensão [PDO](http://www.php.net/manual/en/book.pdo.php) do PHP quanto o driver
do PDO para a base que você está usando (por exemplo, `pdo_mysql` para o MySQL).
PDO para o gerenciador de banco de dados que você está usando (por exemplo, `pdo_mysql` para o MySQL).
Este é um requisito básico se a sua aplicação usa um banco de dados relacional.
Tendo estes instalados, abra o arquivo `config/db.php` e mude os parâmetros para
que estejam corretos para o seu banco de dados. Por padrão, o arquivo contém
o seguinte:
Tendo esses instalados, abra o arquivo `config/db.php` e mude os parâmetros conforme seu banco de dados.
Por padrão, o arquivo contém o seguinte:
```php
<?php
return [
'class' => 'yii\db\Connection',
'dsn' => 'mysql:host=localhost;dbname=yii2basic',
'dsn' => 'mysql:host=localhost;dbname=yii2basico',
'username' => 'root',
'password' => '',
'charset' => 'utf8',
];
```
O arquivo `config/db.php` é uma ferramenta de [configuração](concept-configurations.md)
típica baseada em arquivos. Este arquivo de configuração em particular especifica
os parâmetros necessários para criar e inicializar uma instância de [[yii\db\Connection]]
através da qual você pode fazer consultas de SQL ao banco de dados subjacente.
O arquivo `config/db.php` é uma típica ferramenta de [configuração](concept-configurations.md) baseada em arquivo. Este arquivo de configuração em particular especifica
os parâmetros necessários para criar e inicializar uma instância [[yii\db\Connection]]
por meio da qual você pode fazer consultas SQL ao banco de dados subjacente.
A conexão de BD configurada acima pode ser acessada no código da aplicação
através da expressão `Yii::$app->db`.
A conexão configurada acima pode ser acessada no código da aplicação através da expressão `Yii::$app->db`.
> Informação: O arquivo `config/db.php` será incluso pela configuração principal da
> Info: O arquivo `config/db.php` será absorvido (incluso) pela configuração principal da
aplicação `config/web.php`, que especifica como a instância da [aplicação](structure-applications.md)
deverá ser inicializada. Para mais informações, por favor consulte a seção sobre [Configurações](concept-configurations.md).
deve ser inicializada. Para mais informações, por favor, consulte a seção [Configurações](concept-configurations.md).
Se você precisa trabalhar com bancos de dados para os quais não há suporte nativo no Yii, consulte as seguintes extensões:
- [Informix](https://github.com/edgardmessias/yii2-informix)
- [IBM DB2](https://github.com/edgardmessias/yii2-ibm-db2)
- [Firebird](https://github.com/edgardmessias/yii2-firebird)
- [MariaDB](https://github.com/sam-it/yii2-mariadb)
Criando um Active Record <span id="creating-active-record"></span>
------------------------
Para representar e buscar os dados da tabela `country`, crie uma classe que
deriva de [Active Record](db-active-record.md) chamada `Country`, e salve-a
no arquivo `models/Country.php`.
Para representar e buscar os dados da tabela `pais`, crie uma classe que deriva de [Active Record](db-active-record.md) chamada `Pais` e salve-a
no arquivo `models/Pais.php`.
```php
<?php
@ -105,55 +104,55 @@ namespace app\models;
use yii\db\ActiveRecord;
class Country extends ActiveRecord
class Pais extends ActiveRecord
{
}
```
A classe `Country` estende de [[yii\db\ActiveRecord]]. Você não precisa escrever
nenhum código nela! Só com o código acima, o Yii adivinhará o nome da tabela
A classe `Pais` estende de [[yii\db\ActiveRecord]]. Você não precisa escrever
nenhum código nela! Só com o código acima, o Yii descobrirá o nome da tabela
associada a partir do nome da classe.
> Informação: Se não houver nenhuma correspondência direta do nome da classe com o nome
da tabela, você pode sobrescrever o método [[yii\db\ActiveRecord::tableName()]]
> Info: Se não houver nenhuma correspondência direta do nome da classe com o nome
da tabela, você pode sobrescrever o método [[yii\db\ActiveRecord::tableName()]]
para especificar explicitamente o nome da tabela associada.
Usando a classe `Country`, você pode manipular facilmente os dados na tabela
`country`, conforme é demonstrado nestes fragmentos:
Usando a classe `Pais`, você pode manipular facilmente os dados na tabela
`pais`, conforme é demonstrado nos fragmentos de código a seguir:
```php
use app\models\Country;
use app\models\Pais;
// obtém todas as linhas da tabela country e as ordena pela coluna "name"
$countries = Country::find()->orderBy('name')->all();
// obtém todas as linhas da tabela pais e as ordena pela coluna "nome"
$paises = Pais::find()->orderBy('nome')->all();
// obtém a linha cuja chave primária é "US"
$country = Country::findOne('US');
// obtém a linha cuja chave primária é "BR"
$pais = Pais::findOne('BR');
// exibe "United States"
echo $country->name;
// exibe "Brasil"
echo $pais->nome;
// altera o nome do país para ser "U.S.A." e o salva no banco de dados
$country->name = 'U.S.A.';
$country->save();
// altera o nome do país para "Brazil" e o salva no banco de dados
$pais->nome = 'Brazil';
$pais->save();
```
> Informação: O Active Record é uma maneira poderosa de acessar e manipular os dados
do banco de dados de uma forma orientada a objeto. Você pode encontrar informações
mais detalhadas na seção [Active Record](db-active-record.md). Alternativamente,
você também pode interagir com o banco de dados usando um método de acesso aos
dados de baixo nível chamado [Data Access Objects](db-dao.md).
> Info: O Active Record é uma maneira poderosa de acessar e manipular dados
do banco de dados de uma forma orientada a objetos. Você pode encontrar informações
mais detalhadas na seção [Active Record](db-active-record.md. Alternativamente,
você também pode interagir com o banco de dados usando um método de acesso a
dados em baixo nível chamado [Objeto de Acesso a Dados (Data Access Objects)](db-dao.md).
Criando uma Action <span id="creating-action"></span>
------------------
Para expor os dados de países aos usuários finais, você precisaria de uma nova
action. Ao invés de colocar a nova action no controller (controlador) `site`,
Para disponibiliar os dados de países aos usuários finais, você precisa criar uma nova
action. Em vez de colocar a nova action no controller `site`
como você fez nas seções anteriores, faz mais sentido criar um novo controller
especificamente para todas as actions relacionadas aos dados de países. Chame
este novo controller de `CountryController`, e crie uma action `index` nele,
conforme o exemplo a seguir.
este novo controller de `PaisController`, e crie uma action `index` nele,
conforme o exemplo a seguir:
```php
<?php
@ -162,55 +161,53 @@ namespace app\controllers;
use yii\web\Controller;
use yii\data\Pagination;
use app\models\Country;
use app\models\Pais;
class CountryController extends Controller
class PaisController extends Controller
{
public function actionIndex()
{
$query = Country::find();
$query = Pais::find();
$pagination = new Pagination([
$paginacao = new Pagination([
'defaultPageSize' => 5,
'totalCount' => $query->count(),
]);
$countries = $query->orderBy('name')
->offset($pagination->offset)
->limit($pagination->limit)
$paises = $query->orderBy('nome')
->offset($paginacao->offset)
->limit($paginacao->limit)
->all();
return $this->render('index', [
'countries' => $countries,
'pagination' => $pagination,
'paises' => $paises,
'paginacao' => $paginacao,
]);
}
}
```
Salve o código acima em um arquivo `controllers/CountryController.php`.
Salve o código acima no arquivo `controllers/PaisController.php`.
A action `index` chama `Country::find()`. Este método do Active Record constrói
uma consulta do BD e retorna todos os dados da tabela `country`. Para limitar o
número de países retornados em cada requisição, a consulta é paginada com a ajuda
A action `index` chama `Pais::find()`. Este método do Active Record constrói
uma consulta ao BD e retorna todos os dados da tabela `pais`. Para limitar o
número de países retornados a cada requisição, a consulta é paginada com a ajuda
de um objeto [[yii\data\Pagination]]. O objeto `Pagination` serve para dois propósitos:
* Definir as cláusulas `offset` e `limit` da declaração SQL representada pela
consulta de modo que apenas retorne uma única página de dados por vez (no máximo
* Define as cláusulas `offset` e `limit` da declaração SQL representada pela query
(consulta) de modo que apenas retorne uma única página de dados por vez (no exemplo, no máximo
5 linhas por página).
* É usado para que a view exiba um paginador que consite de uma lista de botões
para as páginas, conforme será explicado na próxima sub-seção.
* É usado na view para exibir um paginador que consiste de uma lista de botões de páginas, conforme será explicado na próxima subseção.
No final do código, a action `index` renderiza uma view chamada `index`, e passa
para ela os dados dos países bem como as informações de paginação.
No final do código, a action `index` renderiza uma view chamada `index` e envia a ela os dados dos países e as informações de paginação.
Criando uma View <span id="creating-view"></span>
----------------
Dentro do diretório `views`, primeiro crie um sub-diretório chamado `country`.
Dentro do diretório `views`, primeiro crie um subdiretório chamado `pais`.
Esta pasta será usada para guardar todas as views renderizadas pelo controller
`country`. Dentro do diretório `views/country`, crie um arquivo `index.php`
`PaisController`. Dentro do diretório `views/pais`, crie um arquivo `index.php`
contendo o seguinte:
```php
@ -218,50 +215,48 @@ contendo o seguinte:
use yii\helpers\Html;
use yii\widgets\LinkPager;
?>
<h1>Countries</h1>
<h1>Países</h1>
<ul>
<?php foreach ($countries as $country): ?>
<?php foreach ($paises as $pais): ?>
<li>
<?= Html::encode("{$country->name} ({$country->code})") ?>:
<?= $country->population ?>
<?= Html::encode("{$pais->nome} ({$pais->codigo})") ?>:
<?= $pais->populacao ?>
</li>
<?php endforeach; ?>
</ul>
<?= LinkPager::widget(['pagination' => $pagination]) ?>
<?= LinkPager::widget(['pagination' => $paginacao]) ?>
```
A view tem duas seções relativas à exibição dos dados dos países. Na primeira parte,
os dados de países fornecidos são cruzados e renderizados como uma lista do HTML.
os dados de países fornecidos são percorridos e renderizados como uma lista HTML.
Na segunda parte, um widget [[yii\widgets\LinkPager]] é renderizado usando as
informações de paginação passadas pela action. O widget `LinkPager` exibe uma
lista de botões para as páginas. Ao clicar em qualquer um deles atualizará
os dados dos países com a página correspondente.
lista de botões de páginas. Clicar em qualquer um deles vai atualizar os dados dos países conforme a página correspondente.
Testando <span id="trying-it-out"></span>
Conferindo <span id="trying-it-out"></span>
--------
Para verificar se todo os códigos acima funcionam, use o seu navegador para
acessar a seguinte URL:
Para ver se todo os códigos acima funcionam, use o seu navegador para acessar a seguinte URL:
```
http://hostname/index.php?r=country/index
http://hostname/index.php?r=pais/index
```
![Lista de Países](images/start-country-list.png)
Primeiramente, você verá uma lista exibindo cinco países. Abaixo dos países,
você verá um paginador com quatro botões. Se você clicar no botão "2", você
verá a página exibindo outros cinco países no banco de dados: a segunda
verá a página exibir outros cinco países do banco de dados: a segunda
página de registros. Observe mais cuidadosamente e você perceberá que a URL no
browser mudou para
```
http://hostname/index.php?r=country/index&page=2
http://hostname/index.php?r=pais/index&page=2
```
Por baixo dos panos, [[yii\data\Pagination|Pagination]] está fornecendo toda
Por trás das cortinas, [[yii\data\Pagination|Pagination]] está fornecendo toda
a funcionalidade necessária para paginar um conjunto de dados:
* Inicialmente, [[yii\data\Pagination|Pagination]] representa a primeira página,
@ -271,8 +266,8 @@ a funcionalidade necessária para paginar um conjunto de dados:
usando as URLs criadas pelo [[yii\data\Pagination::createUrl()|Pagination]].
As URLs conterão um parâmetro `page`, que representa os diferentes números de
páginas.
* Se você clicar no botão da página "2", uma nova requisição para a rota
`country/index` será disparada e tratada. [[yii\data\Pagination|Pagination]] lê
* Se você clicar no botão de página "2", uma nova requisição para a rota
`pais/index` será disparada e tratada. [[yii\data\Pagination|Pagination]] lê
o parâmetro `page` da URL e define o número da página atual como sendo 2. A nova
consulta de países então terá a cláusula `LIMIT 5 OFFSET 5` e retornará os
próximos cinco países para a exibição.
@ -285,9 +280,9 @@ Nesta seção, você aprendeu como trabalhar com um banco de dados. Você també
aprendeu como buscar e exibir dados em páginas com a ajuda do
[[yii\data\Pagination]] e do [[yii\widgets\LinkPager]].
Na próxima seção, você aprenderá como usar a poderosa ferramenta geradora de códigos,
Na próxima seção, você aprenderá como usar a poderosa ferramenta de geração de códigos,
chamada [Gii](tool-gii.md), para ajudá-lo a implementar rapidamente algumas
funcionalidades comumente necessárias, tais como as operações CRUD
(Criar-Ler-Atualizar-Excluir) para trabalhar com os dados em uma tabela do
(Criar-Ler-Atualizar-Excluir) para trabalhar com os dados de uma tabela do
banco de dados. Na verdade, todo o código que você acabou de escrever pode ser
gerado automaticamente no Yii usando a ferramenta Gii.

245
docs/guide-pt-BR/start-forms.md
View File

@ -1,28 +1,26 @@
Trabalhando com Formulários
===========================
Nesta seção descreve como se cria uma nova página com um formulário para obter
dados a partir dos usuários. A página exibirá uma formulário com um campo para
o nome e uma para o e-mail. Depois de obter essas duas informações a partir do
usuário, a página exibirá os valores inseridos de volta para a confirmação.
Esta seção descreve como criar uma nova página com um formulário para receber
dados dos usuários. A página exibirá um formulário com um campo para o nome e outro para o e-mail. Depois de obter essas duas informações do usuário, a página exibirá os valores inseridos de volta para confirmação.
Para atingir este objetivo, além de criar uma [ação](structure-controllers.md) (action) e
duas [visões](structure-views.md) (view), você também criará uma [modelo](structure-models.md) (model).
Para alcançar esse objetivo, além de criar uma [action](structure-controllers.md) e
duas [views](structure-views.md), você também criará um [model](structure-models.md).
Através deste tutorial, você aprenderá como:
No decorrer deste tutorial, você aprenderá como:
* Criar um [modelo](structure-models.md) (model) para representar os dados inseridos pelo usuário por meio de um formulário
* Declarar regras (rules) para validar os dados inseridos
* Criar um formulário HTML em uma [visão](structure-views.md) (view)
* criar um [model](structure-models.md) para representar os dados que o usuário insere por meio de um formulário
* declarar regras (rules) para validar os dados inseridos
* criar um formulário HTML em uma [view](structure-views.md)
Criando uma Modelo (Model) <span id="creating-model"></span>
Criando um Model <span id="creating-model"></span>
----------------
Os dados a serem solicitados pelo usuário será representados por uma classe modelo
`EntryForm` como mostro a seguir e salvos no arquivo `models/EntryForm.php`. Por
favor consulte a seção [Autoloading de Classes](concept-autoloading.md) para mais
detalhes sobre convenção de nomenclatura dos arquivos de classes.
Os dados a serem solicitados do usuário serão representados por uma classe model
`FormularioDeRegistro`, como visto a seguir, que será salva no arquivo `models/FormularioDeRegistro.php`. Por
favor, consulte a seção [Autoloading de Classes](concept-autoloading.md) para mais
detalhes sobre convenção de nomenclatura de arquivos de classes.
```php
<?php
@ -32,62 +30,59 @@ namespace app\models;
use Yii;
use yii\base\Model;
class EntryForm extends Model
class FormularioDeRegistro extends Model
{
public $name;
public $email;
public $nome;
public $e_mail;
public function rules()
{
return [
[['name', 'email'], 'required'],
['email', 'email'],
[['nome', 'e_mail'], 'required'],
[['e_mail'], 'email'],
];
}
}
```
A classe estende de [[yii\base\Model]], uma classe base fornecida pelo Yii,
comumente usados para representar dados do formulário.
A classe estende de [[yii\base\Model]], uma classe base fornecida pelo Yii comumente usada para representar dados de formulários.
> Informação: O [[yii\base\Model]] é usado como pai das classes modelos que *não*
são associadas com tabelas do banco de dados.
O [[yii\db\ActiveRecord]] é normalmente usado como pai das classes modelos que
correspondem a tabelas do banco de dados.
> Info: [[yii\base\Model]] é usado como pai das classes de models que *não*
são associadas com tabelas de bancos de dados.
Enquanto [[yii\db\ActiveRecord]], como pai das classes de models que correspondem a tabelas de bancos de dados.
A classe `EntryForm` contém dois atributos públicos, `name` e `email`, que são
usados para guardar os dados fornecidos pelo usuário. Ele também contém um método
chamado `rules()`, que retorna um conjunto de regras para validação dos dados.
As regras de validação declaradas no código acima permitem que:
A classe `FormularioDeRegistro` contém dois atributos públicos, `nome` e `e_mail`, que são
usados para armazenar os dados fornecidos pelo usuário. Ele também contém um método
chamado `rules()`, que retorna um conjunto de regras para validação dos dados.
As regras de validação declaradas no código acima declaram que:
* tanto os valores do `name` quanto do `email` sejam obrigatórios
* os dados do `email` devem ser um e-mail válido sintaticamente
* tanto o `nome` quanto o `e_mail` são obrigatórios
* o `e_mail` deve ser preenchido com um e-mail sintaticamente válido (por exemplo, um valor sem @ não pode ser considerado válido para um e-mail, etc.)
Se você tiver um objeto `EntryForm` populado com dados fornecidos pelo usuário,
você pode chamar o [[yii\base\Model::validate()|validate()]] para iniciar as
rotinas de validação dos dados. A validação dos dados falhar, a propriedade
Se você tem um objeto `FormularioDeRegistro` preenchido com dados fornecidos pelo usuário,
você pode chamar seu método [[yii\base\Model::validate()|validate()]] para iniciar as rotinas de validação dos dados. Se a validação de dados falhar, a propriedade
[[yii\base\Model::hasErrors|hasErrors]] será definida como *true* e você pode
saber quais erros ocorrerão pela validação através de [[yii\base\Model::getErrors|errors]].
saber quais erros de validação ocorreram por consultar [[yii\base\Model::getErrors|errors]].
```php
<?php
$model = new EntryForm();
$model->name = 'Qiang';
$model->email = 'bad';
$model = new FormularioDeRegistro();
$model->nome = 'Fulano';
$model->e_mail = 'emailruim';
if ($model->validate()) {
// Bom!
} else {
// Falha!
// Falhou!
// Utilize $model->getErrors()
}
```
Criando uma Ação <span id="creating-action"></span>
Criando uma Action <span id="creating-action"></span>
------------------
Em seguida, você precisará criar uma ação `entry` no controlador `site` que será usado no novo modelo. O processo de criação e utilização das ações são explicadas na seção
[Como Fazer um "Hello World"](start-hello.md).
Em seguida, você precisará criar uma action `registro` no controller `site` que usará o novo model. O processo de criação e utilização de ações foi explicado na seção
[Dizendo "Olá!"](start-hello.md).
```php
<?php
@ -96,77 +91,68 @@ namespace app\controllers;
use Yii;
use yii\web\Controller;
use app\models\EntryForm;
use app\models\FormularioDeRegistro;
class SiteController extends Controller
{
// ...código existente...
public function actionEntry()
public function actionRegistro()
{
$model = new EntryForm();
$model = new FormularioDeRegistro();
if ($model->load(Yii::$app->request->post()) && $model->validate()) {
// dados válidos recebidos pelo $model
// dados válidos recebidos no $model
// fazer alguma coisa aqui sobre $model ...
// faça alguma coisa significativa com o $model aqui ...
return $this->render('entry-confirm', ['model' => $model]);
return $this->render('confirmar-registro', ['model' => $model]);
} else {
// Ou a página é exibida inicialmente ou existe algum erro de validação
return $this->render('entry', ['model' => $model]);
// Ou a página esta sendo exibida inicial ou houve algum erro de validação
return $this->render('registro', ['model' => $model]);
}
}
}
```
A primeira ação cria um objeto `EntryForm`. Ele, então, tenta popular o modelo
(model) com os dados vindos do `$_POST`, fornecidos pelo [[yii\web\Request::post()]]
no Yii. Se o modelo (model) for populado com sucesso (por exemplo, se o usuário
enviar o formulário HTML), a ação chamará o [[yii\base\Model::validate()|validate()]]
para certifique-se que os valores fornecidos são válidos.
A primeira action cria um objeto `FormularioDeRegistro`. Ele, então, tenta preencher o model com os dados de `$_POST`, fornecidos no Yii por [[yii\web\Request::post()]].
Se o model for preenchido (observe o método `load()`) com sucesso, ou seja, se o usuário
enviou o formulário HTML, a action chamará o [[yii\base\Model::validate()|validate()]]
para se certificar de que os valores fornecidos são válidos.
> Informação: A expressão `Yii::$app` representa a instância da
[aplicação](structure-applications.md), que é globalmente acessível via singleton.
Também é um [service locator](concept-service-locator.md) que fornece componentes
tais como `request`, `response`, `db`, etc. para suportar a funcionalidade específica.
No código acima, o componente `request` da instância da aplicação é usada para
acessar os dados do `$_POST`.
> Info: A expressão `Yii::$app` representa a instância da
[aplicação](structure-applications.md), que é um "singleton" globalmente acessível.
Ao mesmo tempo, é um [service locator](concept-service-locator.md) que fornece componentes
tais como `request`, `response`, `db`, etc., para permitir funcionalidades específicas.
No código acima, o componente `request` da instância da aplicação é usado para acessar os dados do `$_POST`.
Se tudo tiver certo, a ação renderizará a visão chamada `entry-confirm` para
confirmar os dados enviados pelo usuário. Se ao enviar o formulário não
houver dados ou se os dados tiverem erros, a visão `entry` será renderizada,
em que o formulário será exibigo, juntamente com as mensagens de erros da
validação.
Se tudo estiver certo, a action renderizará a view chamada `confirmar-registro` para confirmar ao usuário que os dados foram enviados corretamente. Se nenhum dado foi enviado ou se tiverem erros, a view `registro` será renderizada novamente
e seu formulário HTML voltará a ser exibido mas, dessa vez, juntamente com as mensagens de erro de validação.
> Nota: Neste exemplo muito simples, acabamos de renderizar um página de confirmação
mediante a dados válidos enviados de uma formulário. Em prática, você poderia
considerar usar [[yii\web\Controller::refresh()|refresh()]] ou [[yii\web\Controller::redirect()|redirect()]]
para evitar [problemas ao reenviar formulários](http://en.wikipedia.org/wiki/Post/Redirect/Get).
> Nota: Neste exemplo muito simples, renderizamos a página de confirmação somente se os dados enviados eram válidos. Na prática, você deve considerar usar [[yii\web\Controller::refresh()|refresh()]] ou [[yii\web\Controller::redirect()|redirect()]]
para evitar [problemas de reenvio de formulário](http://en.wikipedia.org/wiki/Post/Redirect/Get).
Criando Visões <span id="creating-views"></span>
Criando Views <span id="creating-views"></span>
--------------
Finalmente, crie dois arquivos de visões chamados de `entry-confirm` e `entry`.
Estas visões serão renderizados pela ação `entry`, como descrito anteriormente.
Por fim, crie dois arquivos de views chamados `confirmar-registro` e `registro`. Essas serão as views renderizadas pela action `registro`, como acabamos de descrever acima.
A visão `entry-confirm` simplesmente exibe os dados dos campos `name` e `email`.
Deverá ser salvo no arquivo `views/site/entry-confirm.php`.
A view `confirmar-registro` simplesmente exibe os dados dos campos `nome` e `e_mail` e deve ser salva no arquivo `views/site/confirmar-registro.php`.
```php
<?php
use yii\helpers\Html;
?>
<p>You have entered the following information:</p>
<p>Você enviou as seguintes informações:</p>
<ul>
<li><label>Name</label>: <?= Html::encode($model->name) ?></li>
<li><label>Email</label>: <?= Html::encode($model->email) ?></li>
<li><label>Nome</label>: <?= Html::encode($model->nome) ?></li>
<li><label>E-mail</label>: <?= Html::encode($model->e_mail) ?></li>
</ul>
```
A visão `entry` exibe um formulário HTML. Deverá ser salvo no arquivo `views/site/entry.php`.
A view `registro` exibe um formulário HTML e deve ser salva no arquivo `views/site/registro.php`.
```php
<?php
@ -175,97 +161,86 @@ use yii\widgets\ActiveForm;
?>
<?php $form = ActiveForm::begin(); ?>
<?= $form->field($model, 'name') ?>
<?= $form->field($model, 'nome') ?>
<?= $form->field($model, 'email') ?>
<?= $form->field($model, 'e_mail') ?>
<div class="form-group">
<?= Html::submitButton('Submit', ['class' => 'btn btn-primary']) ?>
<?= Html::submitButton('Enviar', ['class' => 'btn btn-primary']) ?>
</div>
<?php ActiveForm::end(); ?>
```
A visão usa o poderoso [widget](structure-widgets.md) chamado
[[yii\widgets\ActiveForm|ActiveForm]] para criar o formulário HTML. Os métodos
`begin()` e `end()` do widget renderizam a abertura e o fechamento da tag do
formulário. Entre os dois métodos chamados, os campos de entrada são criados pelo
método [[yii\widgets\ActiveForm::field()|field()]]. O primeiro campo de entrada
é para o "name" (nome) e o segundo é para o "email". Após os campos de entrada,
o método [[yii\helpers\Html::submitButton()]] é chamado para criar o botão
de enviar.
A view usa um poderoso [widget](structure-widgets.md) chamado
[[yii\widgets\ActiveForm|ActiveForm]] para construir o formulário HTML. Os métodos
`begin()` e `end()` do widget renderizam as tags de abertura e de fechamento do formulário.
Entre as duas chamadas de métido, campos são criados pelo
método [[yii\widgets\ActiveForm::field()|field()]]. O primeiro campo é para o nome e o segundo é para o e-mail. Após os campos,
o método [[yii\helpers\Html::submitButton()]] é chamado para criar um botão de envio do formulário (submit).
Testando <span id="trying-it-out"></span>
Conferindo <span id="trying-it-out"></span>
-------------
Para ver como ele funciona, utilize seu navegador para acessar a seguinte URL:
Para ver como funciona, utilize seu navegador para acessar a seguinte URL:
```
http://hostname/index.php?r=site/entry
http://hostname/index.php?r=site/registro
```
Você verá uma página exibindo um formulário com dois campos de entrada. Na frente
de cada campo, um *label* indicando quais dados devem ser inseridos. Se você clicar
no botão de enviar sem informar nenhum dado, ou se você não fornecer um e-mail
válido, você verá uma mensagem de erro após cada campo de entrada.
Você verá uma página exibindo um formulário com dois campos. Na frente de cada campo, um *label* indica quais dados devem ser inseridos. Se você clicar
no botão Enviar sem informar nenhum dado, ou se você não fornecer um e-mail
válido, você verá uma mensagem de erro próxima a cada campo com problema.
![Form with Validation Errors](images/start-form-validation.png)
![Formulário com Erros de Validação](images/start-form-validation.png)
Após informar um nome e e-mail válidos e clicar no botão de enviar, você verá uma
Após informar um nome e e-mail válidos e clicar no botão de enviar, você verá uma
nova página exibindo os dados informados por você.
![Confirmation of Data Entry](images/start-entry-confirmation.png)
![Confirmação de Registro](images/start-entry-confirmation.png)
### Explicação da Mágica <span id="magic-explained"></span>
### Mágica Explicada <span id="magic-explained"></span>
Você pode querer saber como o formulário HTML trabalha por baixo dos panos, porque
parece quase mágica exibir um *label* para cada campo de entrada e mostrar mensagens
de erro quando você não informa dados corretos sem recarregar a página.
Você talvez se pergunte como o formulário HTML trabalha por trás das cortinas, já que parece
quase mágica exibir um *label* para cada campo e mostrar mensagens
de erro sem recarregar a página quando você não informa os dados corretamente.
Sim, a validação dos dados inicialmente é feito no lado do cliente usando JavaScript
e posteriormente realizada no lado do servidor via PHP.
O [[yii\widgets\ActiveForm]] é inteligente o suficiente para extrair as regras de
validação declaradas no `EntryForm`, transformando-as em códigos JavaScript e utilizando
o JavaScript para realizar as validações dos dados. No caso do JavaScript estiver desabilitado
em seu navegador, a validação ainda será realizada pelo lado do servidor, como mostrado
no método `actionEntry()`. Isso garante que os dados serão validados em qualquer
circunstância.
Sim, a validação de dados inicialmente é feita no cliente usando JavaScript e, posteriormente, realizada no servidor via PHP.
O [[yii\widgets\ActiveForm]] é esperto o suficiente para extrair as regras de
validação que você declarou no `FormularioDeRegistro`, transformá-las em código JavaScript executável e usar esse
código JavaScript para realizar a validação de dados. Caso você tenha desabilitado o JavaScript em seu navegador, a validação ainda será realizada no servidor, como mostrado
no método `actionRegistro()`. Isso garante a validade dos dados em todas as circunstâncias.
> Aviso: A validação feita pelo lado do cliente é uma conveniência que fornece uma melhor
experiência para o usuário. A validação feita pelo lado do servidor é sempre necessária
com ou sem validação no lado do cliente.
> Warning: (Alerta!) A validação feita no cliente é uma conveniência que fornece uma melhor
experiência para o usuário. A validação feita no servidor é sempre necessária, quer a validação no cliente aconteça, quer não.
Os *labels* dos campos de entrada são geradas pelo método `field()`, usando os nomes
das propriedades do modelo (model).
Por exemplo, um *label* chamado `Name` será gerado para a propriedade `name`.
Os *labels* dos campos são gerados pelo método `field()`, usando os nomes
das propriedades do model.
Por exemplo, um *label* chamado `Nome` será gerado para a propriedade `nome`.
Você pode personalizar um *label* em uma visão utilizando o seguinte código:
Você pode personalizar um *label* em uma view utilizando o seguinte código:
```php
<?= $form->field($model, 'name')->label('Your Name') ?>
<?= $form->field($model, 'email')->label('Your Email') ?>
<?= $form->field($model, 'nome')->label('Seu Nome') ?>
<?= $form->field($model, 'e_mail')->label('Seu E-mail') ?>
```
> Informação: O Yii fornece muitos destes widgets para lhe ajudar a criar rapidamente
complexas e dinâmicos layouts.
Como você vai aprender mais tarde, escrever um novo widget é também extremamenet fácil.
Você pode querer transformar grande parte do seu código de visão em reutilizáveis
widget para simplificar o desenvolvimento de visões no futuro.
> Info: O Yii fornece muitos desses widgets para ajudá-lo a construir rapidamente views dinâmicas e complexas.
Conforme você vai aprender mais tarde, escrever um novo widget também é extremamente fácil.
Você talvez queira transformar grande parte do código de suas views em widgets reutilizáveis
para simplificar o desenvolvimento de views no futuro.
Resumo <span id="summary"></span>
-------
Nesta seção, você tocou em cada parte do padrão de arquitetura MVC.
Aprendeu como criar uma classe modelo (model) para representar os dados do usuário
e validá-los.
Nesta seção do guia, você teve uma introduçao à última parte do padrão de arquitetura MVC. Você aprendeu como criar uma classe model para representar os dados do usuário e validá-los.
Também aprendeu como obter os dados enviados pelos usuários e como exibi-los de
volta no navegador. Esta é uma tarefa que poderia levar muito tempo ao desenvolver
uma aplicação, mas o Yii fornece widgets inteligentes para gerar estas tarefas de
forma simples.
Na próxima seção, você aprenderá como trabalhar com banco de dados, os quais são
volta no navegador. Essa é uma tarefa que poderia tomar muito tempo ao desenvolver uma aplicação, mas o Yii fornece widgets poderosos que tornam o processo muito simples.
Na próxima seção, você aprenderá como trabalhar com bancos de dados, que são
necessários em quase todas as aplicações.

66
docs/guide-pt-BR/start-gii.md
View File

@ -1,20 +1,20 @@
Gerando Código com Gii
========================
Essa seção irá descrever como usar o [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) para gerar automaticamente código que implementa algumas funcionalidades comuns de sites. Usar o Gii para gerar código é simples, trata-se apenas de uma questão de entrar com as informações corretas de acordo com as instruções mostradas nas páginas do Gii.
Essa seção irá descrever como usar o [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) para gerar automaticamente código que implementa algumas funcionalidades comuns de sites. Usar o Gii para gerar código é simplesmente uma questão de informar os dados corretos conforme as instruções mostradas nas páginas do Gii.
Através desse tutorial, você irá aprender a:
* Habilitar o Gii em sua aplicação
* Usar o Gii para gerar uma classe Active Record
* Usar o Gii para gerar código que implementa as operações CRUD para uma tabela do BD
* Customizar o código gerado pelo Gii
* habilitar o Gii em sua aplicação,
* usar o Gii para gerar uma classe Active Record,
* usar o Gii para gerar código que implementa as operações CRUD para uma tabela do banco de dados, e
* personalizar o código gerado pelo Gii.
Começando a usar o Gii <span id="starting-gii"></span>
------------
O [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) é fornecido com o Yii como um [módulo](structure-modules.md). Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode já encontrar o seguinte código no arquivo de configuração `config/web.php`:
O [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md) é fornecido como um [módulo](structure-modules.md) do Yii. Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode encontrar o seguinte código já pronto no arquivo de configuração `config/web.php`:
```php
$config = [ ... ];
@ -27,22 +27,22 @@ if (YII_ENV_DEV) {
}
```
A configuração acima declara que quando se está em [ambiente de desenvolvimento](concept-configurations.md#environment-constants), a aplicação deve incluir um módulo chamado `gii`, da classe [[yii\gii\Module]].
A configuração acima declara que, quando estiver usando o [ambiente de desenvolvimento](concept-configurations.md#environment-constants), a aplicação deve incluir um módulo chamado `gii`, da classe [[yii\gii\Module]].
Se você checar o [script inicial](structure-entry-scripts.md) `web/index.php` da sua aplicação, você encontrará a seguinte linha, que essencialmente faz com que o `YII_ENV_DEV` seja verdadeiro.
Se você verificar o [script de entrada](structure-entry-scripts.md) `web/index.php` da sua aplicação, você encontrará a seguinte linha que, basicamente, torna `YII_ENV_DEV` verdadeira.
```php
defined('YII_ENV') or define('YII_ENV', 'dev');
```
Graças a essa linha, sua aplicação está em modo de desenvolvimento e estará com o Gii habilitado, pela configuração acima. Agora você pode acessar o Gii pela URL:
Graças a essa linha, sua aplicação está em modo de desenvolvimento e terá o Gii habilitado, devido a configuração mais acima. Agora você pode acessar o Gii pela URL:
```
http://hostname/index.php?r=gii
```
> Observação: Se você está acessando o Gii por um endereço IP que não seja o localhost, o acesso será negado por padrão.
> Para mudar isso, adicione a lista de endereços IP permitidos à configuração:
> Note: Se você está acessando o Gii por um endereço IP que não seja o localhost, o acesso será negado por padrão, por questões de segurança.
> Você pode configurar o Gii adicionando endereços IP permitidos como mostrado a seguir:
>
```php
'gii' => [
@ -57,32 +57,32 @@ http://hostname/index.php?r=gii
Gerando uma classe Active Record <span id="generating-ar"></span>
---------------------------------
Para usar o Gii para gerar uma classe Active Record, selecione o "Model Generator" clicando no link na página inicial do Gii. Preencha o formulário como indicado abaixo:
Para gerar uma classe Active Record usando o Gii, selecione o "Model Generator" clicando no link na página inicial do Gii. Então, preencha o formulário como indicado abaixo:
* Nome da tabela: `country`
* Classe do modelo: `Country`
* Nome da tabela: `pais`
* Classe do modelo: `Pais`
![Gerador de Modelo](images/start-gii-model.png)
Em seguida, clique no botão "Preview". Você verá o `models/Country.php` listado como arquivo a ser criado. Você pode clicar no nome do arquivo para pré-visualizar seu conteúdo.
Em seguida, clique no botão "Preview". Você verá o `models/Pais.php` listado como arquivo a ser criado. Você pode clicar no nome do arquivo para pré-visualizar seu conteúdo.
Ao usar o Gii, se você já havia criado o mesmo arquivo e pretende sobrescrevê-lo, clique no botão `diff` próximo ao nome do arquivo para ver as diferenças entre o código a ser gerado e a versão já existente.
![Pré-visualização do Gerador de Modelo](images/start-gii-model-preview.png)
Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "overwrite" (sobrescrever) e clique no botão "Generate". Se estiver criando um arquivo novo, apenas clique em "Generate".
Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "overwrite" (sobrescrever) e clique no botão "Generate". Se estiver criando um novo arquivo, apenas clique em "Generate".
Em seguida, você verá uma página de confirmação indicando que o código foi gerado com sucesso. Se você já tinha um arquivo, também verá uma mensagem indicando que ele foi sobrescrito com o novo código.
Em seguida, você verá uma página de confirmação indicando que o código foi gerado com sucesso. Se você já tinha um arquivo, também verá uma mensagem indicando que ele foi sobrescrito pelo novo código.
Gerando código CRUD <span id="generating-crud"></span>
--------------------
CRUD corresponde a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria dos sites. Para criar funcionalidades CRUD usando o Gii, selecione "CRUD Generator" clicando no link na página inicial do Gii. Seguindo o exemplo "country", preencha o formulário com as seguintes informações:
CRUD significa a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria das aplicações. Para criar funcionalidades CRUD usando o Gii, selecione "CRUD Generator" clicando no link na página inicial do Gii. Seguindo o exemplo "pais", preencha o formulário com as seguintes informações:
* Classe do Modelo: `app\models\Country`
* Classe da Busca: `app\models\CountrySearch`
* Classe do Controller: `app\controllers\CountryController`
* Model Class: `app\models\Pais`
* Search Model Class: `app\models\PaisSearch`
* Controller Class: `app\controllers\PaisController`
![Gerador de CRUD](images/start-gii-crud.png)
@ -90,38 +90,38 @@ Em seguida, clique no botão "Preview". Você verá uma lista de arquivos a sere
![Pré-visualização do Gerador de CRUD](images/start-gii-crud-preview.png)
Se você criou anteriormente os arquivos `controllers/CountryController.php` e
`views/country/index.php` (na seção de banco de dados deste guia), marque a caixa "overwrite" para substitui-los. (As versões anteriores não tinham suporte completo às operações CRUD.)
Se você criou anteriormente os arquivos `controllers/PaisController.php` e
`views/pais/index.php` (na seção de banco de dados deste guia), marque a caixa "overwrite" para substitui-los. (As versões anteriores não tinham suporte completo às operações CRUD.)
Checando os resultados <span id="trying-it-out"></span>
Conferindo <span id="trying-it-out"></span>
-------------
Para ver como ficou, use seu navegador para acessar a seguinte URL:
```
http://hostname/index.php?r=country/index
http://hostname/index.php?r=pais/index
```
Você verá uma tabela mostrando os países do seu banco de dados. Você pode ordená-los ou filtrá-los inserindo condições nos cabeçalhos das colunas.
Para cada país exibido na tabela, você pode visualizar detalhes, editar ou excluir.
Você também pode clicar no botão “Create Country” no topo da tabela para ter acesso a um formulário de criação de um novo país.
Você também pode clicar no botão “Create Pais” no topo da tabela para ter acesso a um formulário para cadastrar um novo país.
![Tabela de Países](images/start-gii-country-grid.png)
![Grade de Países](images/start-gii-country-grid.png)
![Editando um País](images/start-gii-country-update.png)
Essa é uma lista de arquivos gerados pelo Gii, caso você queira investigar como essas funcionalidades são implementadas ou adaptá-las:
Esta é uma lista de arquivos gerados pelo Gii, caso você queira investigar como essas funcionalidades estão implementadas ou ajustá-las:
* Controller: `controllers/CountryController.php`
* Modelo: `models/Country.php` e `models/CountrySearch.php`
* Views: `views/country/*.php`
* Controller: `controllers/PaisController.php`
* Modelo: `models/Pais.php` e `models/PaisSearch.php`
* Views: `views/pais/*.php`
> Informação: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você irá acelerar o desenvolvimento da sua aplicação. Para mais detalhes, por favor siga para a seção [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md).
> Info: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você pode acelerar bastante o desenvolvimento de sua aplicação. Para mais detalhes, por favor, consulte a seção [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide-pt-BR/README.md).
Resumo <span id="summary"></span>
-------
Nessa seção, você aprendeu a usar o Gii para gerar código que implementa funcionalidades CRUD para o conteúdo guardado em uma tabela do banco de dados.
Nessa seção, você aprendeu a usar o Gii para gerar código que implementa todas as operações CRUD para o conteúdo armazenado em uma tabela de banco de dados.

174
docs/guide-pt-BR/start-hello.md
View File

@ -1,38 +1,33 @@
Como Fazer um "Hello World"
Dizendo "Olá!"
=====================
Esta seção descreve como criar uma nova página de "Hello" em sua aplicação.
Para atingir este objetivo, você criará uma [ação](structure-controllers.md#creating-actions)
(action) e uma [visão](structure-views.md) (view):
Esta seção descreve como criar uma nova página de "Olá!" em sua aplicação.
Para atingir este objetivo, você criará uma [action](structure-controllers.md#creating-actions)
e uma [view](structure-views.md):
* A aplicação enviará a requisição de página para a ação
* e a ação por sua vez renderizará a view que mostra as palavras "Hello"
para o usuário final.
* A aplicação enviará a requisição de página para a action
* e a action, por sua vez, renderizará a view que mostra a palavra "Olá!" ao usuário final.
Através deste tutorial, você aprenderá três coisas:
1. Como criar uma [ação](structure-controllers.md) para responder às requisições,
2. como criar uma [visão](structure-views.md) para compor o conteúdo da resposta, e
3. como uma aplicação envia as requisições para as [ações](structure-controllers.md#creating-actions).
1. Como criar uma [action](structure-controllers.md) para responder às requisições,
2. como criar uma [view](structure-views.md) para compor o conteúdo da resposta, e
3. como uma aplicação envia requisições às [actions](structure-controllers.md#creating-actions).
Criando uma Ação <span id="creating-action"></span>
Criando uma Action <span id="creating-action"></span>
----------------
Para a tarefa "Hello", você criará uma [ação](structure-controllers.md#creating-actions)
`say` que lê um parâmetro `message` da requisição e exibe essa mensagem de volta
para o usuário. Se a requisição não fornecer um parâmetro `message`, a ação
exibirá a mensagem padrão "Hello".
Para a tarefa "Olá!", você criará uma [action](structure-controllers.md#creating-actions)
`cumprimentar` que lê um parâmetro `mensagem` da requisição e exibe essa mensagem de volta
para o usuário. Se a requisição não fornecer um parâmetro `mensagem`, a action exibirá a mensagem padrão "Olá!".
> Informação: [Ações](structure-controllers.md#creating-actions) são os objetos aos
quais os usuários finais podem se referir diretamente para execução. As ações são
agrupadas nos [controladores](structure-controllers.md) (controllers). O resultado
da execução de uma ação é a resposta que o usuário final receberá.
> Info: [Actions](structure-controllers.md#creating-actions) são os objetos que usuários finais podem solicitar diretamente para execução. Actions são
agrupadas nos [controllers](structure-controllers.md). O resultado da execução de uma action é a resposta que o usuário final receberá.
As ações devem ser declaradas em [controladores](structure-controllers.md). Por
motivo de simplicidade, você pode declarar a ação `say` na classe já existente
`SiteController`. Este controlador está definido no arquivo `controllers/SiteController.php`.
Segue aqui o início da nova ação:
As actions devem ser declaradas em [controllers](structure-controllers.md). Para manter a simplicidade, você pode declarar a action `cumprimentar` na classe já existente
`SiteController`. Esse controller está definido no arquivo `controllers/SiteController.php`.
Segue aqui o início da nova action:
```php
<?php
@ -45,125 +40,116 @@ class SiteController extends Controller
{
// ...código existente...
public function actionSay($message = 'Hello')
public function actionCumprimentar($mensagem = 'Olá!')
{
return $this->render('say', ['message' => $message]);
return $this->render('cumprimentar', ['mensagem' => $mensagem]);
}
}
```
No código acima, a ação `say` está definida como um método chamado `actionSay`
na classe `SiteController`. O Yii usa o prefixo `action` para diferenciar métodos
de ações de métodos que não são de ações em uma classe de controlador. O nome
após o prefixo `action` é mapeado para o ID da ação.
No código acima, a action `cumprimentar` está definida como um método chamado `actionCumprimentar`
na classe `SiteController`. O Yii usa o prefixo `action` para diferenciar os métodos
de actions dos métodos que não são de actions em uma classe de controller. O nome após o prefixo `action` é mapeado como o ID da action.
Quando se trata de dar nome às suas ações, você deveria entender como o Yii
trata os IDs de ações. Os IDs das ações são sempre referenciados em minúsculo.
Se o ID de uma ação necessitar de múltiplas palavras, elas serão concatenadas
por hífens (por exemplo, `create-comment`). Os nomes de métodos de ações são mapeados
para os IDs das ações removendo-se os hífens dos IDs, colocando em maiúsculo a
Quando se trata de dar nome às suas actions, você deveria entender como o Yii
trata os IDs de actions. Os IDs de actions são sempre referenciados em minúsculo.
Se o ID de uma action necessitar de múltiplas palavras, elas serão concatenadas
por hífens (por exemplo, `criar-comentario`). Os IDs de actions são convertidos em nomes de actions removendo-se os hífens dos IDs, colocando em maiúscula a
primeira letra de cada palavra, e prefixando o resultado com a palavra `action`. Por exemplo,
o ID de ação `create-comment` corresponde ao método de ação `actionCreateComment`.
o ID de action `criar-comentario` corresponde ao método de action `actionCriarComentario`.
O método de ação em nosso exemplo recebe um parâmetro `$message`, cujo valor
padrão é "Hello" (exatamente da mesma forma que você define um valor padrão para
O método da action em nosso exemplo recebe um parâmetro `$mensagem`, cujo valor
padrão é "Olá!" (exatamente da mesma forma que você define um valor padrão para
qualquer argumento de função ou método no PHP). Quando a aplicação recebe a
requisição e determina que a ação `say` é responsável por tratar a requisição,
a aplicação alimentará este parâmetro com o parâmetro de mesmo nome encontrado
na requisição. Em outras palavras, se a requisição inclui um parâmetro `message`
com o valor `"Goodbye"`, a variável `$message` na ação receberá esse valor.
requisição e determina que a action `cumprimentar` é responsável por tratar a requisição,
a aplicação vai preencher esse parâmetro com o parâmetro que tiver o mesmo nome
na requisição. Em outras palavras, se a requisição inclui um parâmetro `mensagem`
com o valor `"Adeus!"`, a variável `$mensagem` na action receberá esse valor.
Dentro do método da ação, [[yii\web\Controller::render()|render()]] é chamado
para renderizar um arquivo de [visão](structure-views.md) chamado `say`. O
parâmetro `message` também é passado para a visão de modo que ele possa ser usado
ali. O resultado da renderização é retornado pelo método da ação. Esse resultado
será recebido pela aplicação, e exibido para o usuário final no navegador (como
parte de uma página HTML completa).
Dentro do método da action, [[yii\web\Controller::render()|render()]] é chamado
para renderizar um arquivo de [view](structure-views.md) chamado `cumprimentar`. O
parâmetro `mensagem` também é passado para a view de modo que ele possa ser usado
por ela. O resultado da renderização da view é retornado pelo método da action. Esse resultado
será recebido pela aplicação e exibido para o usuário final no navegador (como parte de uma página HTML completa).
Criando uma Visão <span id="creating-view"></span>
Criando uma View <span id="creating-view"></span>
-----------------
As [visões](structure-views.md) são scripts que você escreve para gerar o conteúdo
de uma resposta. Para a tarefa "Hello", você criará uma visão `say` que imprime o
parâmetro `message` recebido do método da ação:
As [views](structure-views.md) são scripts que você escreve para gerar o conteúdo de uma resposta.
Para a tarefa "Olá!", você criará uma view `cumprimentar` que exibe o parâmetro `mensagem` recebido do método da action:
```php
<?php
use yii\helpers\Html;
?>
<?= Html::encode($message) ?>
<?= Html::encode($mensagem) ?>
```
A visão `say` deve ser salva no arquivo `views/site/say.php`. Quando o método
[[yii\web\Controller::render()|render()]] é chamado em uma ação, ele procurará
um arquivo PHP chamado de `views/IDdoController/NomeDaView.php`.
A view `cumprimentar` deve ser salva no arquivo `views/site/cumprimentar.php`. Quando o método
[[yii\web\Controller::render()|render()]] é chamado em uma action, ele procurará
o arquivo PHP em `views/IDdoController/NomeDaView.php`.
Perceba que no código acima o parâmetro `message` é [[yii\helpers\Html::encode()|codificado como HTML]]
Perceba que no código acima o parâmetro `mensagem` é [[yii\helpers\Html::encode()|codificado como HTML]]
antes de ser impresso. Isso é necessário, já que o parâmetro vem de um usuário final,
tornando-o vulnerável a [ataques de cross-site scripting (XSS)](http://en.wikipedia.org/wiki/Cross-site_scripting)
onde coloca-se código JavaScript malicioso no parâmetro.
por embutir código JavaScript malicioso no parâmetro.
Naturalmente, você pode colocar mais conteúdo na visão `say`. O conteúdo pode consistir
de tags HTML, texto puro, ou até mesmo instruções de PHP. De fato a visão `say` é
Naturalmente, você pode colocar mais conteúdo na view `cumprimentar`. O conteúdo pode consistir
de tags HTML, texto puro, ou até mesmo instruções de PHP. De fato, a view `cumprimentar` é
apenas um script PHP que é executado pelo método [[yii\web\Controller::render()|render()]].
O conteúdo impresso pelo script da visão será retornado à aplicação como o resultado
da resposta. A aplicação, por sua vez, retornará este resultado para o usuário final.
O conteúdo impresso pelo script da view será retornado à aplicação como o resultado
da resposta. A aplicação, por sua vez, retornará esse resultado para o usuário final.
Testando <span id="trying-it-out"></span>
Conferindo <span id="trying-it-out"></span>
--------
Após criar a ação e a visão, você pode acessar a nova página através da seguinte URL:
Após criar a action e a view, você pode acessar a nova página através da seguinte URL:
```
http://hostname/index.php?r=site/say&message=Hello+World
http://hostname/index.php?r=site/cumprimentar&mensagem=Olá+Mundo!
```
![Hello World](images/start-hello-world.png)
![Olá Mundo!](images/start-hello-world.png)
Esta URL resultará em uma página exibindo "Hello World". Esta página compartilha
o mesmo cabeçalho e rodapé das outras páginas da aplicação.
Essa URL resultará em uma página exibindo "Olá Mundo!". Essa página compartilha o mesmo cabeçalho e rodapé das outras páginas da aplicação.
Se você omitir o parâmetro `message` na URL, você veria a página exibindo somente
"Hello". Isso é porque `message` é passado como um parâmetro para o método `actionSay()`,
e quando ele é omitido, o valor padrão `"Hello"` será usado ao invés dele.
Se você omitir o parâmetro `mensagem` na URL, você verá a página exibindo somente
"Olá!". Isso ocorre por que `mensagem` é passado como um parâmetro para o método `actionCumprimentar()` e,
quando ele é omitido, o valor padrão `"Olá!"` é usado em seu lugar.
> Informação: A nova página compartilha o mesmo cabeçalho e rodapé de outras páginas
porque o método [[yii\web\Controller::render()|render()]] irá automaticamente
incluir o resultado da visão `say` em um [layout](structure-views.md#layouts)
> Info: A nova página compartilha o mesmo cabeçalho e rodapé de outras páginas
porque o método [[yii\web\Controller::render()|render()]] vai automaticamente
incluir o resultado da view `cumprimentar` em um [layout](structure-views.md#layouts)
que neste caso está localizado em `views/layouts/main.php`.
O parâmetro `r` na URL acima requer mais explicação. Ele significa [rota](runtime-routing.md),
um ID abrangente e único de uma aplicação que se refere a uma ação. O formato da rota
um ID único e amplo de uma aplicação que se refere a uma action. O formato da rota
é `IDdoController/IDdaAction`. Quando a aplicação recebe uma requisição, ela
verificará este parâmetro, usando a parte `IDdoController` para determinar qual
classe de controlador deve ser instanciada para tratar a requisição. Então o
controlador usará a parte `IDdaAction` para determinar qual ação deverá ser
instanciada para fazer o trabalho. No caso deste exemplo, a rota `site/say` será
resolvida como a classe de controlador `SiteController` e a ação `say`. Como
resultado, o método `SiteController::actionSay()` será chamado para tratar a requisição.
verificará esse parâmetro e usará a parte `IDdoController` para determinar qual
classe de controller deve ser instanciada para tratar a requisição. Então o
controller usará a parte `IDdaAction` para determinar qual action deverá ser
instanciada para fazer o trabalho. No caso deste exemplo, a rota `site/cumprimentar` será
resolvida como a classe de controller `SiteController` e a action `cumprimentar`. Como
resultado, o método `SiteController::actionCumprimentar()` será chamado para tratar a requisição.
> Informação: Assim como as ações, os controladores também possuem IDs que os identificam
de maneira única em uma aplicação. Os IDs de controladores seguem as mesmas regras
de nomenclatura que os IDs de ações. Os nomes das classes de controlllers
derivam dos IDs de controladores removendo-se os hífens dos IDs, convertendo a
> Info: Assim como as actions, os controllers também possuem IDs que os identificam
de maneira única em uma aplicação. IDs de controllers seguem as mesmas regras de nomenclatura dos IDs de actions. Os nomes das classes de controlllers
derivam dos IDs de controllers removendo-se os hífens dos IDs, convertendo a
primeira letra de cada palavra em maiúscula, e adicionando o sufixo `Controller`.
Por exemplo, o ID de controlador `post-comment` corresponde ao nome de classe
de controlador `PostCommentController`.
Por exemplo, o ID de controller `comentario-de-artigo` corresponde ao nome de classe
de controller `ComentarioDeArtigoController`.
Resumo <span id="summary"></span>
------
Nesta seção, você tocou as partes do controlador (controller) e da visão (view)
do padrão de arquitetura MVC. Você criou uma ação (action) como parte de um controlador
para tratar uma requisição específica. E você também criou uma visão para compor
o conteúdo da resposta. Neste exemplo simples acima, nenhum modelo (model) foi
utilizado, já que os único dado sendo exibido foi o parâmetro `message`.
Nesta seção, você teve uma introdução sobre as partes controller e view do padrão de arquitetura MVC. Você criou uma action como parte de um controller para tratar uma requisição específica.
E você também criou uma view para compor o conteúdo da resposta. Nesse exemplo simples, nenhum modelo (model) foi
utilizado, já que o único dado exibido foi o parâmetro `mensagem`.
Você também aprendeu sobre as rotas no Yii, que agem como a ponte entre as
requisições do usuário e as ações do controlador.
requisições de usuário e as actions de controllers.
Na próxima seção, você aprenderá como criar um modelo e adicionar uma nova
página contendo um formulário HTML.
Na próxima seção, você aprenderá como criar um modelo (model) e adicionar uma nova página contendo um formulário HTML.

38
docs/guide-pt-BR/start-looking-ahead.md
View File

@ -1,44 +1,36 @@
Seguindo em Frente
==================
Se você leu a seção "Primeiros Passos" inteira, você criou uma aplicação Yii
completa. Neste processo, você aprendeu como implementar algumas funcionalidades
comumente necessárias, tais como obter dados de usuários através de um formulário
HTML, consultar dados de um banco de dados, e exibir os dados de forma paginada.
Se você leu toda a seção "Primeiros Passos", você criou uma aplicação Yii
completa. No processo, você aprendeu como implementar algumas funcionalidades comumente necessárias, tais como obter dados de usuários através de um formulário
HTML, consultar dados de um banco de dados e exibir os dados de forma paginada.
Você também aprendeu a usar o [Gii](tool-gii.md) para gerar código automaticamente.
Usar o Gii para a geração de código torna a carga do seu processo de desenvolvimento
Web uma tarefa tão simples quanto preencher alguns formulários.
Esta seção resume as referências sobre o Yii que lhe ajudarão a ser mais produtivo
usando o framework.
Esta seção resume recursos Yii disponíveis que o ajudarão a ser mais produtivo usando o framework.
* Documentação
- [O Guia Definitivo](http://www.yiiframework.com/doc-2.0/guide-README.html):
Conforme o nome indica, o guia define precisamente como o Yii deve funcionar
e fornece orientações gerais sobre como usar o Yii. É o tutorial
mais importante, e que você deveria ler antes de escrever qualquer código
com o Yii.
e fornece orientações gerais sobre como usá-lo. É o tutorial mais importante e que você deveria ler antes de escrever qualquer código Yii.
- [A Referência de Classes](http://www.yiiframework.com/doc-2.0/index.html):
Especifica o uso de todas as classes disponibilizadas pelo Yii. Deve ser
principalmente usado quando você estiver escrevendo o código e quiser entender
o uso de uma classe, método ou propriedade em particular. O uso da referência
de classes só é melhor depois de um entendimento contextual do framework
inteiro.
- [Os Artigos do Wiki](http://www.yiiframework.com/wiki/?tag=yii2):
Os artigos do wiki escritos pelos usuários do Yii baseados em suas próprias
experiências. A maioria deles são escritos como receitas de bolo, e mostram
como resolver problemas em particular usando o Yii. Enquanto a qualidade destes
artigos pode não ser tão boa quanto a do Guia Definitivo, eles ainda assim
são úteis porque são mais abrangentes e frequentemente fornecem
Especifica o uso de todas as classes fornecidas pelo Yii. Deve ser
principalmente usada quando você estiver escrevendo código e quiser entender o uso de uma classe, método ou propriedade específicos. O uso da referência
de classes é idealmente melhor somente depois de um entendimento contextual do framework como um todo.
- [Os Artigos Wiki](http://www.yiiframework.com/wiki/?tag=yii2):
Os artigos wiki são escritos por usuários do Yii baseados em suas próprias experiências. A maioria deles são escritos como receitas de bolo e mostram
como resolver problemas específicos usando o Yii. Ainda que a qualidade desses artigos possa não ser tão boa quanto a do Guia Definitivo, eles são úteis porque são abrangem assuntos adicionais e frequentemente fornecem
soluções prontas para serem usadas.
- [Livros](http://www.yiiframework.com/doc/)
* [Extensões](http://www.yiiframework.com/extensions/):
O Yii ostenta uma biblioteca de milhares de extensões contribuídas por usuários,
que podem facilmente ser plugadas em suas aplicações, desta forma tornando
O Yii ostenta uma biblioteca de milhares de extensões contribuídas por usuários que podem facilmente ser plugadas em suas aplicações, tornando
o seu desenvolvimento ainda mais rápido e mais fácil.
* Comunidade
- Fórum: <http://www.yiiframework.com/forum/>
- Chat do IRC: O canal #yii na rede freenode (<irc://irc.freenode.net/yii>)
- Chat IRC: O canal #yii na rede freenode (<irc://irc.freenode.net/yii>)
- Canal Slack: <https://yii.slack.com>
- Chat Gitter: <https://gitter.im/yiisoft/yii2>
- GitHub: <https://github.com/yiisoft/yii2>
- Facebook: <https://www.facebook.com/groups/yiitalk/>
- Twitter: <https://twitter.com/yiiframework>

82
docs/guide-pt-BR/start-workflow.md
View File

@ -2,20 +2,17 @@ Executando Aplicações
=====================
Após instalar o Yii, você tem uma aplicação Yii funcional que pode ser acessada
pela URL `http://hostname/basic/web/index.php` ou `http://hostname/index.php`,
dependendo da sua configuração. Esta seção introduzirá a funcionalidade embutida
da aplicação, como o código é organizado, e como a aplicação manuseia as requisições
em geral.
pela URL `http://hostname/basico/web/index.php` ou `http://hostname/index.php`,
dependendo de sua configuração. Esta seção introduzirá a funcionalidade embutida
da aplicação, como o código é organizado e como a aplicação trata as requisições em geral.
> Info: Por questões de simplicidade, por todo este tutorial de "Primeiros Passos"
assume-se que você definiu `basic/web` como a raiz de documentos do seu
assume-se que você definiu `basico/web` como a raiz de documentos do seu
servidor Web e configurou a URL de acesso de sua aplicação como `http://hostname/index.php`
ou algo semelhantes. Por favor ajuste as URLs em nossas descrições às suas
necessidades.
ou algo semelhante.
Por favor, ajuste as URLs em nossas descrições conforme necessário.
Observe que ao contrário do próprio framework, após a instalação de um dos templates
de projetos, você está livre para adicionar, remover ou sobrescrever qualquer código
que precisar.
Observe que, ao contrário do framework em si, após o template de projeto ser instalado, ele é todo seu. Você está livre para adicionar ou remover código e modificar o template conforme precisar.
Funcionalidade <span id="functionality"></span>
@ -27,32 +24,27 @@ O template básico de projetos instalado contém quatro páginas:
* a página "About" (Sobre),
* a página "Contact" (Contato), que exibe um formulário de contato que permite
que usuários finais entrem em contato com você via e-mail,
* e a página "Login", que exibe um formulário de login que pode ser usado
para aurenticar usuários finais. Tente fazer o login com "admin/admin", e
você perceberá que o item do menu principal "Login" mudará para "Logout".
* e a página "Login", que exibe um formulário de login que pode ser usado para aurenticar usuários finais.
Tente fazer o login com "admin/admin", e você perceberá que o item do menu principal "Login" mudará para "Logout".
Estas páginas compartilham um cabeçalho e rodapé em comum. O cabeçalho contém
uma barra de menu principal que permite a navegação através das diferentes páginas.
Essas páginas compartilham o mesmo cabeçalho e rodapé. O cabeçalho contém uma barra de menu principal que permite a navegação entre as diferentes páginas.
Você também deverá ver uma barra de ferramentas no rodapé da janela do navegador.
Essa é uma [ferramenta de depuração](tool-debugger.md) fornecida pelo Yii para
registrar e exibir várias informações de depuração, tais como mensagens de logs,
status de respostas, as consultas de banco de dados executadas, e assim por diante.
Essa é uma [ferramenta de depuração](tool-debugger.md) muito útil fornecida pelo Yii para
registrar e exibir várias informações de depuração, tais como: mensagens de logs, status de respostas, as consultas de banco de dados executadas, e assim por diante.
Além da aplicação Web, existe um script de console chamado `yii`, que está localizado no diretório raiz da aplicação.
Esse script pode ser usado para executar rotinas em segundo plano e tarefas de manutenção da aplicação que são descritas na seção [Comandos de Console](tutorial-console.md).
Além da aplicação Web, existe um script console chamado `yii`, que está localizado
na pasta base da aplicação.
Este script pode ser usado para executar rotinas em segundo plano e tarefas de
manutenção da aplicação, descritas na [seção Comandos de Console](tutorial-console.md).
Estrutura da Aplicação <span id="application-structure"></span>
----------------------
Os diretórios e arquivos mais importantes em sua aplicação são (assumindo que
o diretório raiz de sua aplicação é `basic`):
Os diretórios e arquivos mais importantes em sua aplicação, assumindo que o diretório raiz dela é o `basico`, são:
```
basic/ caminho base de sua aplicação
composer.json usado pelo Composer, descreve as informações de pacotes
basico/ caminho base de sua aplicação
composer.json usado pelo Composer, descreve informações de pacotes
config/ contém as configurações da aplicação e outras
console.php a configuração da aplicação de console
web.php a configuração da aplicação Web
@ -68,10 +60,8 @@ basic/ caminho base de sua aplicação
yii o script de execução dos comandos de console do Yii
```
Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles em
`basic/web` e aqueles em outros diretórios. Os primeiros podem ser acessados
diretamente via HTTP (ou seja, em um navegador), enquanto os segundos não podem
e nem deveriam.
Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles em `basico/web` e aqueles em outros diretórios.
Os primeiros podem ser acessados diretamente via HTTP (ou seja, em um navegador), enquanto os demais não podem e deveriam ser acessados.
O Yii implementa o padrão de arquitetura [modelo-visão-controlador (MVC)](http://wikipedia.org/wiki/Model-view-controller),
que se reflete na organização de diretórios acima. O diretório `models` contém
@ -84,36 +74,30 @@ O diagrama a seguir demonstra a estrutura estática de uma aplicação.
![Estrutura Estática de uma Aplicação](images/application-structure.png)
Cada aplicação tem um script de entrada `web/index.php` que é o único script PHP
acessível pela Web na aplicação. O script de entrada recebe uma requisição e
cria uma instância da [aplicação](structure-applications.md) para gerenciá-la.
A [aplicação](structure-applications.md) resolve a requisição com a ajuda de seus
[componentes](concept-components.md), e despacha a requisição para os elementos
do MVC. São usados [Widgets](structure-widgets.md) nas [views](structure-views.md)
para ajudar a construir elementos de interface de usuário complexos e dinâmicos.
acessível pela Web na aplicação. O script de entrada recebe uma requisição e cria uma instância de [aplicação](structure-applications.md) para tratar a requisição.
A [aplicação](structure-applications.md) resolve ("traduz") a requisição com a ajuda de seus [componentes](concept-components.md) e despacha a requisição para os elementos do MVC. São usados [Widgets](structure-widgets.md) nas [views](structure-views.md) para ajudar a construir elementos de interface de usuário complexos e dinâmicos.
Ciclo de Vida da Requisição <span id="request-lifecycle"></span>
---------------------------
O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
O diagrama a seguir demonstra como uma aplicação trata uma requisição.
![Ciclo de Vida da Requisição](images/request-lifecycle.png)
1. Um usuário faz uma requisição ao [script de entrada](structure-entry-scripts.md) `web/index.php`.
2. O script de entrada carrega a [configuração](concept-configurations.md) da
aplicação e cria uma instância da [aplicação](structure-applications.md) para
gerenciar a requisição.
3. A aplicação resolve a [rota](runtime-routing.md) solicitada com a ajuda do
componente de aplicação [request](runtime-requests.md).
aplicação e cria uma instância de [aplicação](structure-applications.md) para
tratar a requisição.
3. A aplicação resolve ("traduz") a [rota](runtime-routing.md) solicitada com a ajuda do componente [request](runtime-requests.md) da aplicação.
4. A aplicação cria uma instância de um [controller](structure-controllers.md)
para gerenciar a requisição.
5. O controller cria uma instância de um [action](structure-controllers.md) (ação)
e aplica os filtros para a ação.
para tratar a requisição.
5. O controller cria uma instância de uma [action](structure-controllers.md) (ação) e aplica os filtros para a ação.
6. Se qualquer filtro falhar, a ação é cancelada.
7. Se todos os filtros passarem, a ação é executada.
8. A ação carrega um modelo de dados, possivelmente a partir de um banco de dados.
9. A ação renderiza uma view, fornecendo a ela o modelo de dados.
10. O resultado renderizado é retornado pelo componente de aplicação
[response](runtime-responses.md) (resposta).
11. O componente *response* envia o resultado renderizado para o navegador do usuário.
8. A ação carrega alguns modelos (models) de dados, possivelmente a partir de um banco de dados.
9. A ação renderiza uma view, passando a ela os modelos de dados.
10. O resultado renderizado é retornado pelo componente
[response](runtime-responses.md) (resposta) da aplicação.
11. O componente response envia o resultado renderizado para o navegador do usuário.

6
docs/guide/start-hello.md
View File

@ -54,7 +54,7 @@ The name after the `action` prefix maps to the action's ID.
When it comes to naming your actions, you should understand how Yii treats action IDs. Action IDs are always
referenced in lower case. If an action ID requires multiple words, they will be concatenated by dashes
(e.g., `create-comment`). Action method names are mapped to action IDs by removing any dashes from the IDs,
(e.g., `create-comment`). Action method IDs are mapped to action names by removing any dashes from the IDs,
capitalizing the first letter in each word, and prefixing the resulting string with `action`. For example,
the action ID `create-comment` corresponds to the action method name `actionCreateComment`.
@ -67,7 +67,7 @@ a `message` parameter with a value of `"Goodbye"`, the `$message` variable withi
Within the action method, [[yii\web\Controller::render()|render()]] is called to render
a [view](structure-views.md) file named `say`. The `message` parameter is also passed to the view
so that it can be used there. The rendering result is returned by the action method. That result will be received
by the application and displayed to the end user in the browser (as part of a complete HTML page).
by the application and displayed to the end user in the browser (as part of a complete HTML page).
Creating a View <span id="creating-view"></span>
@ -107,7 +107,7 @@ http://hostname/index.php?r=site%2Fsay&message=Hello+World
![Hello World](images/start-hello-world.png)
This URL will result in a page displaying "Hello World". The page shares the same header and footer as the other application pages.
This URL will result in a page displaying "Hello World". The page shares the same header and footer as the other application pages.
If you omit the `message` parameter in the URL, you would see the page display just "Hello". This is because `message` is passed as a parameter to the `actionSay()` method, and when it is omitted,
the default value of `"Hello"` will be used instead.