Commit dda46109 by Davidson Alencar Committed by Carsten Brandt

docs/guide-pt-BR/start-workflow.md - typo

close #6216 docs/guide-pt-BR/start-forms.md - translate close #6218 docs/guide-pt-BR/start-databases.md - typo close #6219 docs/guide-pt-BR/start-gii.md - typo/fixed close #6221 docs/guide-pt-BR/start-looking-ahead.md - update close #6222 docs/guide-pt-BR/structure-overview.md - typo close #6223 docs/guide-pt-BR/structure-entry-scripts.md - typo close #6224
parent 94a50417
......@@ -12,11 +12,11 @@ Através 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 modo paginado
* 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 declarações SQL usando uma ferramente de cliente
banco de dados, e como executar instruções SQL usando uma ferramenta de cliente
de BD.
......@@ -86,7 +86,7 @@ através da qual você pode fazer consultas de 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`.
> Info: O arquivo `config/db.php` será incluso pela configuração principal da
> Informação: O arquivo `config/db.php` será 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).
......@@ -114,7 +114,7 @@ A classe `Country` estende de [[yii\db\ActiveRecord]]. Você não precisa escrev
nenhum código nela! Só com o código acima, o Yii adivinhará o nome da tabela
associada a partir do nome da classe.
> Info: Se não houver nenhuma correspondência direta do nome da classe com o nome
> 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()]]
para especificar explicitamente o nome da tabela associada.
......@@ -138,8 +138,8 @@ $country->name = 'U.S.A.';
$country->save();
```
> Info: O Active Record é uma maneira poderosa de acessar e manipular os dados
do banco de dados de um modo orientado a objeto. Você pode encontrar informações
> 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).
......@@ -242,7 +242,7 @@ os dados dos países com a página correspondente.
Testando <a name="trying-it-out"></a>
--------
Para verificar se todo o código acima funciona, use o seu navegador para
Para verificar se todo os códigos acima funcionam, use o seu navegador para
acessar a seguinte URL:
```
......
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.
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).
Através 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)
Criando uma Modelo (Model) <a name="creating-model"></a>
----------------
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.
```php
<?php
namespace app\models;
use yii\base\Model;
class EntryForm extends Model
{
public $name;
public $email;
public function rules()
{
return [
[['name', 'email'], 'required'],
['email', 'email'],
];
}
}
```
A classe estende de [[yii\base\Model]], uma classe base fornecida pelo Yii,
comumente usados para representar dados do formulário.
> 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.
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:
* tanto os valores do `name` quanto do `email` sejam obrigatórios
* os dados do `email` devem ser um e-mail válido sintaticamente
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
[[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]].
```php
<?php
$model = new EntryForm();
$model->name = 'Qiang';
$model->email = 'bad';
if ($model->validate()) {
// Bom!
} else {
// Falha!
// Utilize $model->getErrors()
}
```
Criando uma Ação <a name="creating-action"></a>
------------------
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).
```php
<?php
namespace app\controllers;
use Yii;
use yii\web\Controller;
use app\models\EntryForm;
class SiteController extends Controller
{
// ...código existente...
public function actionEntry()
{
$model = new EntryForm;
if ($model->load(Yii::$app->request->post()) && $model->validate()) {
// dados válidos recebidos pelo $model
// fazer alguma coisa aqui sobre $model ...
return $this->render('entry-confirm', ['model' => $model]);
} else {
// Ou a página é exibida inicialmente ou existe algum erro de validação
return $this->render('entry', ['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.
> 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`.
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.
> 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).
Criando Visões <a name="creating-views"></a>
--------------
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.
A visão `entry-confirm` simplesmente exibe os dados dos campos `name` e `email`.
Deverá ser salvo no arquivo `views/site/entry-confirm.php`.
```php
<?php
use yii\helpers\Html;
?>
<p>You have entered the following information:</p>
<ul>
<li><label>Name</label>: <?= Html::encode($model->name) ?></li>
<li><label>Email</label>: <?= Html::encode($model->email) ?></li>
</ul>
```
A visão `entry` exibe um formulário HTML. Deverá ser salvo no arquivo `views/site/entry.php`.
```php
<?php
use yii\helpers\Html;
use yii\widgets\ActiveForm;
?>
<?php $form = ActiveForm::begin(); ?>
<?= $form->field($model, 'name') ?>
<?= $form->field($model, 'email') ?>
<div class="form-group">
<?= Html::submitButton('Submit', ['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.
Testando <a name="trying-it-out"></a>
-------------
Para ver como ele funciona, utilize seu navegador para acessar a seguinte URL:
```
http://hostname/index.php?r=site/entry
```
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.
![Form with Validation Errors](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
nova página exibindo os dados informados por você.
![Confirmation of Data Entry](images/start-entry-confirmation.png)
### Explicação da Mágica <a name="magic-explained"></a>
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.
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.
> 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.
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`.
Você pode personalizar um *label* em uma visão utilizando o seguinte código:
```php
<?= $form->field($model, 'name')->label('Your Name') ?>
<?= $form->field($model, 'email')->label('Your Email') ?>
```
> 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.
Resumo <a name="summary"></a>
-------
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.
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
necessários em quase todas as aplicações.
......@@ -14,7 +14,7 @@ Através desse tutorial, você irá aprender a:
Começando a usar o Gii <a name="starting-gii"></a>
------------
[Gii](tool-gii.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](tool-gii.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`:
```php
$config = [ ... ];
......@@ -68,7 +68,7 @@ Ao usar o Gii, se você já havia criado o mesmo arquivo e pretende sobrescrevê
![Pré-visualização do Gerador de Modelo](images/start-gii-model-preview.png)
Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "sobrescrever" e clique no botão "Gerar". Se estiver criando um arquivo novo, apenas clique em "Gerar".
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".
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.
......@@ -76,7 +76,7 @@ Em seguida, você verá uma página de confirmação indicando que o código foi
Gerando código CRUD <a name="generating-crud"></a>
--------------------
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 "Gerador CRUD" clicando no link na página inicial do Gii. Seguindo o exemplo "country", preencha o formulário com as seguintes informações:
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:
* Classe do Modelo: `app\models\Country`
* Classe da Busca: `app\models\CountrySearch`
......@@ -116,7 +116,7 @@ Essa é uma lista de arquivos gerados pelo Gii, caso você queira investigar com
* Modelo: `models/Country.php` e `models/CountrySearch.php`
* Views: `views/country/*.php`
> Info: 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](tool-gii.md).
> 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](tool-gii.md).
Resumo <a name="summary"></a>
......
......@@ -4,7 +4,7 @@ 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 modo paginado.
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.
......@@ -13,25 +13,25 @@ Esta seção resume as referências sobre o Yii que lhe ajudarão a ser mais pro
usando o framework.
* Documentação
- O Guia Definitivo:
- [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.
- A Referência de Classes (Class Reference):
- [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:
- [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
soluções prontas para serem usadas.
- Livros
- [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
......
......@@ -7,7 +7,7 @@ dependendo da sua configuração. Esta seção introduzirá a funcionalidade emb
da aplicação, como o código é organizado, e como a aplicação manuseia as requisições
em geral.
> Info: Por questões de simpicidade, por todo este tutorial de "Primeiros Passos"
> 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
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
......@@ -17,7 +17,7 @@ em geral.
Funcionalidade <a name="functionality"></a>
--------------
A aplicação básica contém quatro páginas:
A aplicação básica instalada contém quatro páginas:
* A página inicial, exibida quando você acessa a URL `http://hostname/index.php`,
* a página "About" (Sobre),
......@@ -65,7 +65,7 @@ Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles
diretamente via HTTP (ou seja, em um navegador), enquanto os segundos não podem
e nem deveriam.
O Yii implementa o padrão de projeto [modelo-visão-controlador (MVC)](http://wikipedia.org/wiki/Model-view-controller),
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
todas as [classes de modelos](structure-models.md), o diretório `views` contém todos
os [scripts de visões](structure-views.md), e o diretório `controllers` contém
......@@ -77,7 +77,7 @@ O diagrama a seguir demonstra a estrutura estática de uma aplicação.
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 manejá-la.
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)
......@@ -91,7 +91,7 @@ O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
![Ciclo de Vida da Requisição](images/request-lifecycle.png)
1. Um usuário faz uma requisiçao ao [script de entrada](structure-entry-scripts.md) `web/index.php`.
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.
......@@ -99,8 +99,8 @@ O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
componente de aplicação [request](runtime-requests.md).
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 da [action](structure-controllers.md) (ação)
e aplica os filtros da ação.
5. O controller cria uma instância de um [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.
......
......@@ -2,7 +2,7 @@ Scripts de Entrada
==================
Scripts de entrada são o primeiro passo no processo de inicialização da aplicação.
Uma aplicação (seja uma aplicação Web ou do console) possui um único script de
Uma aplicação (seja uma aplicação Web ou uma aplicação console) possui um único script de
entrada. Os usuários finais fazem requisições a scripts de entrada que criam
as instâncias da aplicação e redirecionam as requisições para elas.
......@@ -27,7 +27,7 @@ O trabalho principal dos scripts de entrada é o seguinte:
* Chamar [[yii\base\Application::run()]] para processar as requisições que chegam.
## Aplicações da Web <a name="web-applications"></a>
## Aplicações Web <a name="web-applications"></a>
Este é o código no script de entrada para o [Modelo Básico de Aplicação Web](start-installation.md).
......@@ -51,7 +51,7 @@ $config = require(__DIR__ . '/../config/web.php');
```
## Aplicações do Console <a name="console-applications"></a>
## Aplicações Console <a name="console-applications"></a>
De forma semelhante, o seguinte é o código do script de entrada de uma aplicação
do console:
......
......@@ -15,7 +15,7 @@ Além do MVC, as aplicações do Yii também possuem as seguintes entidades:
ciclo de tratamento de uma requisição.
* [aplicações](structure-applications.md): são objetos globalmente acessíveis que
gerenciam os componentes da aplicação e os coordenam para atender às requisições.
* [componentes de aplicação](structure-application-components.md): são objetos
* [componentes da aplicação](structure-application-components.md): são objetos
registrados com as aplicações e fornecem vários serviços para atender às
requisições.
* [módulos](structure-modules.md): são pacotes auto-contidos que contém um MVC
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment