Vous êtes sur la page 1sur 189

começando

Laravel
Um guia para iniciantes para
desenvolvimento de aplicações com Laravel 5.3
-
Sanjib Sinha

www.allitebooks.com
começando Laravel
Um guia para iniciantes para desenvolvimento de
aplicações com Laravel 5.3

Sanjib Sinha

www.allitebooks.com
começando Laravel

Sanjib Sinha
Howrah, Bengala Ocidental, Índia ISBN-13

(pbk): 978-1-4842-2537-0 ISBN-13 (electrónico): 978-1-4842-2538-7


DOI 10,1007 / 978-1-4842-2538-7

Biblioteca do Congresso de controlo do número: 2016962198 de Copyright

© 2017 pela Sanjib Sinha

Este trabalho está sujeito a direitos de autor. Todos os direitos são reservados pelo Publisher, se o todo ou parte do material está
em causa, especificamente, os direitos de tradução, reimpressão, a reutilização de ilustrações, recitação, transmissão, reprodução
de microfilmes ou de qualquer outra forma física, e armazenamento de transmissão ou informações e recuperação, adaptação
eletrônico, software de computador ou através de metodologia similar ou não atualmente conhecida ou posteriormente
desenvolvida.

nomes de marcas comerciais, os logotipos e as imagens podem aparecer neste livro. Ao invés de usar um símbolo de marca
registrada com cada ocorrência de uma marca registrada nome, logotipo ou imagem que usar os nomes, logotipos e imagens
apenas de maneira editorial e em benefício do proprietário da marca, sem intenção de violação da marca registrada. O uso
nesta publicação dos nomes comerciais, marcas comerciais, marcas de serviço e termos similares, mesmo que eles não são
identificados como tal, não deve ser tomado como uma expressão de opinião quanto à possibilidade ou não estão sujeitas a
direitos de propriedade.

Enquanto os conselhos e informações contidas neste livro são acreditados para ser verdadeiras e precisas na data de
publicação, nem os autores nem os editores nem o editor pode aceitar qualquer responsabilidade legal por quaisquer
erros ou omissões que possam ser feitas. A editora não dá garantia, expressa ou implícita, no que diz respeito ao
material aqui contido.

Diretor: Welmoed Spahr Chumbo editor:


Nikhil Karkal
Avaliador Técnico: Yogesh Sharma & Gaurav Yadav
Conselho Editorial: Steve Anglin, Pramila Balan, Laura Berendson, Aaron Preto,
Louise Corrigan, Jonathan Gennick, Robert Hutchinson, Celestin Suresh John, Nikhil Karkal, James
Markham, Susan McDermott, Matthew Moodie, Natalie Pao, Gwenan Spearing

Coordenação do Editor: Prachi Mehta Copiar


editor: Brendan Geada Compositor: SPI global
indexador: SPI global Artista: SPI global

Distribuído para o comércio de livros em todo o mundo pela Springer Science + Business Media Nova York, 233 Spring
Street, 6th Floor, New York, NY 10013. Telefone 1-800-Springer, fax (201) 348-4505, e-mail orders-ny@springer-sbm.com , ou
visita www.springeronline.com . Apress Media, LLC é uma Califórnia LLC e o único membro (proprietário) é Springer Science
+ Business Media Finance Inc (SSBM Finanças Inc). SSBM Finanças Inc é uma Delaware corporação. Para obter
informações sobre traduções, envie um e-mail rights@apress.com , ou visita www.apress.com .

Apress e os amigos de livros ED podem ser comprados em grandes quantidades para uso acadêmico, corporativo ou promocional.
versões do eBook e licenças também estão disponíveis para a maioria dos títulos. Para mais informações, consultar o nosso página
web Licenciamento Vendas de maioria-eBook especial no
www.apress.com/bulk-sales .
Qualquer código-fonte ou outros materiais complementares referenciados pelo autor neste texto estão disponíveis para os
leitores a www.apress.com . Para obter informações detalhadas sobre como localizar o código-fonte do seu livro, ir para www.apress.com/source-code
. Os leitores também podem acessar o código-fonte em SpringerLink na seção Material Suplementar para cada capítulo.
Impresso em papel isento de ácido

www.allitebooks.com
NA MEMÓRIA DO DR. Baidyanath Haldar.

Sir, eu realmente sinto sua falta.

www.allitebooks.com
Conteúdo at a Glance

Sobre o autor ix Sobre os Revisores técnicos Agradecimentos xi xiii

■ Capítulo 1: Compositor 1

■ Capítulo 2: Laravel Homestead, o Virtual Box, e Vagrant 7

■ Capítulo 3: Estrutura do Arquivo 15

■ Capítulo 4: Routing, um método estático 21

■ Capítulo 5: Controlador Classe 29

■ Capítulo 6: Ver e Blade 41

■ Capítulo 7: Meio Ambiente 47

■ Capítulo 8: Migração de banco de dados 49

■ Capítulo 9: Eloquent 53

■ Capítulo 10: Modelo, Vista, controlador de fluxo de trabalho 59

■ Capítulo 11: SQLite é uma brisa! 63

■ Capítulo 12: Sentimentos complicadas de formulários administrativos 65

■ Capítulo 13: Um aplicativo CRUD 67

■ Capítulo 14: Autenticação e Autorização 81

■ Capítulo 15: Mais Sobre Validação 91

■ Capítulo 16: Relações Eloquent 123

www.allitebooks.com
■ Conteúdo em um relance

■ Capítulo 17: Como Segurança e autenticação trabalhar juntos 153

■ Capítulo 18: Pedido de Como, trabalho de resposta em Laravel 5 161

■ Capítulo 19: Contratos vs Fachadas 167

■ Capítulo 20: Middleware, filtro de camada, e Extra Segurança 173

índice 187

vi

www.allitebooks.com
Conteúdo

Sobre o autor ix Sobre os Revisores técnicos Agradecimentos xi xiii

■ Capítulo 1: Compositor 1

■ Capítulo 2: Laravel Homestead, o Virtual Box, e Vagrant 7

2.1 Instalação Virtual Box e Vagrant ............................................ ...... 7

2.2 Instalação Homestead Vagrant Box ............................................. .... 9

2.3 Homestead Instalação e Configuração ................................... 10

■ Capítulo 3: Estrutura do Arquivo 15

3.1 Princípio design sólido .............................................. ................... 17

3.2 Interfaces e Método Injecção ............................................. ..... 19

■ Capítulo 4: Routing, um método estático 21

4,1 Routing Melhores Práticas .............................................. ................. 25

4.2 rotas nomeadas ............................................... ............................... 26

4.3 Organizar arquivos por via ............................................. ......... 27

4,4 conceito avançado de Routing e anónimos Funções ........... 28

■ Capítulo 5: Controlador Classe 29

5.1 RESTful Controlador ............................................... ......................... 32

5.2 O papel de um controlador de ............................................. ......................... 33

5,3 Controlador Versátil ............................................... .................. 34

vii

www.allitebooks.com
■ Conteúdo

5,4 Controlador, IOC recipiente, e interface 35 ........................................

5.5 Resumo ................................................ ...................................... 38

■ Capítulo 6: Ver e Blade 41

■ Capítulo 7: Meio Ambiente 47

■ Capítulo 8: Migração de banco de dados 49

8.1 Resumo ................................................ ...................................... 52

■ Capítulo 9: Eloquent 53

■ Capítulo 10: Modelo, Vista, controlador de fluxo de trabalho 59

10.1 Resumo ................................................ .................................... 61

10.1.1 O nosso próximo desafio ............................................ ....................................... 61

■ Capítulo 11: SQLite é uma brisa! 63

■ Capítulo 12: Sentimentos complicadas de formulários administrativos 65

■ Capítulo 13: Um aplicativo CRUD 67

■ Capítulo 14: Autenticação e Autorização 81

■ Capítulo 15: Mais Sobre Validação 91

15.1 Regras condicionais ............................................... ...................... 112

15,2 Personalizado Validação ............................................... ..................... 113

15.3 Como validação de formulário Works ............................................. ........ 119

■ Capítulo 16: Relações Eloquent 123

■ Capítulo 17: Como Segurança e autenticação trabalhar juntos 153

■ Capítulo 18: Pedido de Como, trabalho de resposta em Laravel 5 161

■ Capítulo 19: Contratos vs Fachadas 167

■ Capítulo 20: Middleware, filtro de camada, e Extra Segurança 173

índice 187

viii

www.allitebooks.com
Sobre o autor

Sanjib Sinha escreve histórias e códigos-nem sempre na mesma ordem.


Ele começou com C # e .NET framework e ganhou o Prêmio Microsoft Community Contributor em 2011.
Mais tarde, o movimento do software de código aberto atraiu e ele tornou-se um entusiasta Linux, PHP e Python,
especializada e trabalhar em Hat Branco Ethical Hacking.

Como um novato, ele sempre teve que lutar muito para encontrar uma maneira fácil de aprender codificação. Ninguém lhe
disse que a codificação é como a escrita-vislumbrando uma imagem e trazê-lo para baixo na terra com a ajuda de palavras e
símbolos.
Através de todos os seus livros, ele tentou ajudar os iniciantes a partir de sua perspectiva, como um novato.

ix

www.allitebooks.com
Sobre os Revisores
Técnicos

Yogesh Sharma Eu sou um desenvolvedor web, consultor de TI e um empresário com sede em Pune, na Índia. Eu
experimentei com muitos paradigma gostou Cloud Services, NoSQL, Middleware mas a programação é a minha
heart.Graduated de Vidyalankar Escola Superior de Tecnologia da Informação, estou empregado atualmente com uma
empresa da Fortune 500 como Engenheiro de Infraestrutura Sênior.

Eu realmente gostaria de ver a imagem grande com olho por complexidades distintas. Eu tenho 8 anos de experiência
acumulada em vários domínios e clientela também serviram em todo o mundo a desenvolver projectos que vão de Gestão de
Ativos de Produção e Logística. Eu gosto de mexer com a Internet das coisas, AI, Discurso e Simulação. Se eu não sou
desses, você pode encontrar-me cerveja um café expresso shot!"

Gaurav Yadav é uma pilha completa Web Developer e blogueiro. Atleta de coração e ama futebol. Ele tem
experiência com vários quadros em PHP, Python e JavaScript. Gosta de explorar novos quadros e evoluir com
a tecnologia de tendências.

XI

www.allitebooks.com
Agradecimentos

Kartick PAUL, gestor do sistema, AAJKAAL, KOLKATA: Sem a sua ajuda persistente e inspiradora, eu não
poderia ter escrito este livro.

xiii
CAPÍTULO 1

Compositor

Compositor é uma ferramenta de gestão dependência em PHP (Figura  1-1 ). Para qualquer projeto PHP você precisa usar sua
biblioteca de códigos. Compositor consegue facilmente essa tarefa em seu nome, ajudando-o a declarar esses códigos. Você
também pode instalar ou atualizar qualquer código em sua biblioteca através Composer. Por favor visite https://getcomposer.org para
mais detalhes.

Figura 1-1. home page Compositor

Na página de abertura https://getcomposer.org , clique no link 'Introdução' (Figura  2/1 ).

material suplementar eletrônico A versão on-line deste capítulo (doi: 10,1007 / 978-1-4842-2538-7_1 ) Contém
material suplementar, que está disponível para usuários autorizados.

© Sanjib Sinha 2017 1


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_1
Capítulo 1 ■ Compositor

Figura 1-2. Obtendo página começou em website Compositor

Na página mostrada na Figura  2/1 , Você encontra dois links: 'localmente' e 'global'. fica
para duas opções. Suponha que você não deseja executar Compositor globalmente ou centralmente em seu sistema. Nesse
caso, você tem que baixar e instalar Compositor de cada vez para cada projeto. Mas a opção global é sempre preferível porque
uma vez Composer está instalado na pasta bin sistema, você pode chamá-lo a qualquer momento para qualquer projeto.

Se você já está acostumado a qualquer distribuição Linux como Ubuntu, você sabe que para qualquer projeto PHP
locais, utilizado para ir para '/ Var / www / html' pasta. Suponha que estamos indo para construir um projeto simples Laravel
e queremos nomeá-lo 'MyFirstLaravelProject'. Abra seu terminal Ubuntu (ctrl + alt + t) e ir para essa pasta primeiro.

Para chegar lá, você precisa digitar o seguinte comando em seu terminal:

cd / var / www / html /

Uma vez que você alcançou isso, você pode fazer um diretório aqui com um simples comando:

sudo mkdir MyFirstLaravelProject

Ele vai pedir a sua senha de usuário 'root'. Digite a senha e uma pasta chamada
'MyFirstLaravelProject' será criado.
Em seguida nesta pasta vamos baixar e instalar 'compositor'. Considerando que você é um novato, por razões
de brevidade Quero baixar e instalar Compositor localmente no nosso projeto Laravel.

2
Capítulo 1 ■ Compositor

Em seguida, emitir estes dois comandos, um após o outro. Primeiro você digite o seguinte:

sudo php -r "cópia ( 'https://getcomposer.org/installer',


'compositor-setup.php');"

Vai levar algum tempo. Próximo tipo isto:

sudo php compositor-setup.php

Vai organizar seu arquivo de configuração Compositor ir mais longe. Na verdade o seu Composer está pronto para baixar os pacotes

para o seu projeto que vem. Você pode testá-lo através da criação de um 'compositor. 'Arquivo dentro do seu 'json pasta

MyFirstLaravelProject'. Nesse arquivo 'composer.json' digite o seguinte:

{
"Exigir": {
"Monólogo / monólogo": "1.0. *"}}

O que isto significa? Isso significa que você está instalando o pacote php 'monólogo' para o seu projeto Laravel. Será
que vai chegar a qualquer uso imediato? A resposta é não'. Na verdade, estamos testando nosso instalador Compositor e quero
ver como ele funciona.
Agora você pode emitir o comando que irá instalar o pacote 'monólogo' para você. Digite este comando em
seu terminal:

sudo php composer.phar instalar

Vai levar um pouco de tempo para instalar o pacote 'monólogo'. Depende da velocidade da sua Internet.

Após a instalação é mais você encontrará uma pasta 'fornecedor' e alguns arquivos 'compositor' dentro do seu projeto.
Sinta-se livre para descobrir o que está dentro da pasta 'fornecedor'. Lá você encontrará duas pastas: 'compositor' e
'monólogo'. Mais uma vez você pode ver o que eles têm dentro deles. Como um novato, é uma viagem sem fim para descobrir
coisas novas. Tente se familiarizar com tudo novo que você encontrou.

Chegou a hora de instalar Laravel 5.2 através Composer. Você pode instalar Laravel como monólogo. Isso significa
que você pode escrever que a instrução no seu arquivo 'composer.json' e apenas atualizar o seu Composer. Mas como
um novato eu recomendo seguir o método mais simples.

Abra seu terminal e escrever o seguinte:

sudo compositor criar-projeto --prefer-dist laravel blog / laravel

Vai instalar Laravel versão mais recente na pasta de 'blog' em seu projeto Laravel
'MyFirstLaravelProject'. Uma vez feito isso você vai ter esta mensagem em seu terminal:

tecla de aplicação
[Base64: FrbQTSPezY8wQq + 2 + bZ / ieA8InA4KjA9N4A44AMbqas =] definida com sucesso.

3
Capítulo 1 ■ Compositor

É uma chave aleatória gerada cada vez que você instalar Laravel. Isso significa que você instalou com
sucesso Laravel 5.3.

• Primeira etapa concluída: você instalou Laravel no '/ var / www / html / MyFirstLaravelProject /
blog' pasta. Agora você pode ir dentro dessa pasta e emitir 'ls -la' um comando Linux para ver
o que está dentro. Você também pode digitar 'php artesão servir' comando para executar o
seu primeiro aplicativo Laravel de modo que você pode ir para http: // localhost: 8000

para ver a página de boas-vindas. Esta instalação foi feito localmente.

Há um outro método, mais fácil. Você pode instalar Compositor globalmente no seu sistema Linux. Abra o terminal
e fazer um diretório chamado 'Código' no ambiente de trabalho. Abra seu terminal e digite o seguinte:

cd / Desktop

Agora você está dentro de sua área de trabalho. Você vai fazer o diretório 'Código' lá. Digite o seguinte:

Código mkdir

Agora você deve ir dentro do diretório seu 'Código' escrevendo 'cd Code' no seu terminal. Em seguida, pasta
dentro 'Código' fazer um diretório 'test', onde você criar seu primeiro aplicativo Laravel.

Não só isso, após o 'Laravel / Homestead' está instalado, você pode digitar http: // test. aplicativo para executar o seu
primeiro aplicativo Laravel. Vou mostrar-lhe que passo a passo.
Agora é hora de instalar Compositor globalmente. Digite estes comandos um após o outro:

sudo php -r "cópia ( 'https://getcomposer.org/installer',


'compositor-setup.php');"

sudo php compositor-setup.php

sudo php composer.phar instalar

Vai demorar alguns minutos para instalar Compositor globalmente. Depois de ter feito isso, você pode criar qualquer projeto Laravel

em qualquer lugar.

Em seguida, você pode criar seu primeiro projeto Laravel dentro da pasta 'Code / test', digitando este comando:

sudo compositor criar-projeto --prefer-dist laravel blog / laravel

Dentro da pasta 'test', o projeto Laravel é instalado como 'blog'. Durante a instalação, você pode alterar esse nome
para sua escolha.
Vai demorar alguns minutos, dependendo da velocidade de sua conexão de Internet.

4
Capítulo 1 ■ Compositor

Uma vez feito, ele vai dar esta mensagem:

tecla de aplicação
[Base64: FrbQTSPezY8wQq + 2 + bZ / ieA8InA4KjA9N4A44AMbqas =] definida com sucesso.

Você instalou a última versão do Laravel 5.2.4 em seu '/ Desktop / Cd / test / blog' pasta. E você tem feito isso
globalmente. Sinta-se livre para criar qualquer pasta e subpastas em qualquer lugar em sua máquina e instalar
Laravel através Composer.

• Segunda etapa concluída: Laravel instalado na pasta '/ Desktop / Código / test / blog', e
você fez isso globalmente.

No próximo capítulo, vamos aprender um pouco sobre a instalação Laravel Homestead.

5
CAPÍTULO 2

Laravel Homestead, o Virtual Box,


e Vagrant

Laravel Homestead é um funcionário, a caixa Vagrant pré-embalados. Um novato absoluto pode encontrar esse conceito um
pouco peculiar. Você pode imaginá-lo como uma plataforma de andaime ou caixa mágica que contém tudo para construir
aplicações Laravel em sua máquina local. Encorajo-vos a pesquisar e aprender sobre o pacote Laravel Homestead. Se você
tem Laravel Homestead instalado, você não precisa se preocupar com o mais recente PHP e versões do Linux. Ele também
vem com um servidor web e todos os tipos de software de servidor que você precisa desenvolver algumas aplicações PHP
impressionantes além Laravel!

Antes de executar Laravel / Homestead você deve ter Box 5.x Virtual:

https://www.virtualbox.org/wiki/Downloads .

Você também deve instalar Vagrant:

http://www.vagrantup.com/downloads.html .

2.1 Instalando o Virtual Box e Vagrant


A primeira pergunta que vem à nossa mente é o seguinte: por que precisamos de uma “caixa virtual” quando temos um
sistema operacional padrão no lugar? Há várias razões. A razão mais importante é que no Virtual Box podemos jogar com
qualquer sistema operacional sem qualquer medo de estragar tudo, mesmo quebrá-lo. Não há qualquer possibilidade de
que ao testar uma ferramenta de hacking poderíamos quebrar um sistema. Convido você a fazer isso. É uma máquina
virtual. Então, vá em frente. Testar tudo o que vem à mente. Outro grande motivo de usar o Virtual Box é a segurança.
Quando você visita um site que você pode considerá-lo para ser seguro, mas na realidade não poderia ser assim. Mas
nada importa, no caso do Virtual Box. Não é a máquina original com dados confidenciais. Visitar sites não seguros não é
irritante (ou pior) mais.

Há apenas uma coisa que você precisa lembrar. Ficar dentro da lei. Ao testar o seu ferramentas de hacking ou correr
códigos, você não pode colocar em risco qualquer outro sistema.
A Caixa site oficial Virtual a Oracle oferece uma abundância de opções de download. Você pode escolher qualquer um deles.
De acordo com seu sistema operacional, você vai para a seção de “download” e ver o que está disponível para você. A partir da
Figura  2-1 , Você vai ganhar uma idéia de como prosseguir.

© Sanjib Sinha 2017 7


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_2
Capítulo 2 ■ LaraveL herdade, o Virtual Box, e errante

Figura 2-1. seção Virtual Box de download para hosts Linux

A linha seleccionada na figura  2-1 mostra o sistema operacional padrão Estou executando atualmente.
Isso é “Ubuntu 14.04 (Trusty)” ea arquitetura é “AMD64”.
Virtual Box é muito fácil de instalar. Seja qual for o seu sistema operacional for-Mac OS X, Windows ou Linux, você pode
instalá-lo. Primeiro você precisa saber sobre o seu próprio sistema operacional. Pode ser de 32 bits ou de arquitectura de 64 bits.
Em qualquer distribuição Linux é extremamente fácil de aprender. Apenas abra o terminal e digite “ uname -a ”.

O terminal vai cuspir fora algumas informações vitais que inclui todos os dados sobre o sistema padrão atual.
Neste caso, o Linux é a versão 3.19.0 e o nome do superusuário “ hagudu “; finalmente, ele também indica que tipo de
arquitetura do sistema está sendo usado.
Como no meu caso, é “x86_64”, que significa 64 bits. Na página de download Virtual Box oficial para toda a
distribuição Linux, você primeiro baixar os pacotes necessários e, em seguida, instalá-los de acordo com a natureza do seu
sistema operacional. Para Red Hat, Fedora, ou qualquer distribuição Linux que pertence a essa categoria, você vai notar que
a última extensão é “.rpm”. Nesse caso, você pode mover para a pasta Virtual Box e enviar comandos do tipo “ rpm -i ”Ou“ yum
install ”No caso de você executar o Red Hat ou Fedora.

Mas existem métodos mais simples de instalar o Virtual Box.


Para os iniciantes, é muito útil para executar distribuição “Ubuntu” Linux como seu sistema operacional
padrão. Você pode instalar o Virtual Box do centro da software diretamente sem abrir o terminal ou a emissão de
qualquer comando.
“Ubuntu” centro de software tem muitas categorias. Um deles mostra o software “instalado”.

8
Capítulo 2 ■ LaraveL herdade, o Virtual Box, e errante

Você não pode encontrá-lo lá por padrão. Nesse caso, é extremamente fácil de instalar. Você pode simplesmente digitar
“Virtual Box” na caixa de pesquisa de texto e ele irá aparecer. Seguir em frente e pressione o botão de instalação e ele vai ficar
instalado em seu sistema. Instalando Vagrant também é fácil. Ir para o site oficial e baixá-lo de acordo com seus sistemas
operacionais. O processo de instalação também é fácil. Para o Ubuntu, basta extrair o conteúdo em qualquer lugar e instalá-lo
de acordo com o procedimento mencionado no site. Pesquisar na Internet você vai ter uma tonelada de guias.

Através Virtual Box você pode executar diferentes sistemas operacionais em sua máquina (Figura  2-2 ).

Figura 2-2. A Virtual Box correndo Kali Linux e Windows XP

Tendo instalado o Virtual Box você pode emitir ' -v vagabundo' comando em seu terminal e a mensagem irá
aparecer como ' 1.8.5' vagabundo. Está correndo.
Agora é hora de instalar Laravel / Homestead.

2.2 Instalação Homestead Vagrant Box


Depois de ter instalado o Virtual Box e Vagrant, você pode adicionar a caixa 'laravel / herdade' para a sua caixa Vagrant
usando este comando em seu terminal:

caixa de vagabundo adicionar laravel / Homestead

Vai levar algum tempo, em qualquer lugar de 15 minutos a uma hora, dependendo da velocidade da Internet.

9
Capítulo 2 ■ LaraveL herdade, o Virtual Box, e errante

2.3 Homestead Instalação e Configuração


Em seguida, você pode instalar Homestead clonando repositório Homestead para a pasta '/ home / Homestead'
usando este comando:

git clone https://github.com/laravel/homestead.git herdade

Vai demorar alguns segundos. Em seguida, você precisa iniciar o seu Homestead e criar o arquivo de configuração.

init.sh festa

Em seguida, executar um ' ls -la' comando para descobrir o oculto' ./ herdade' diretório. Tipo ' cd ./homestead' comando
para entrar nele e correr ' ls -la' comando novamente. Você vai encontrar um arquivo chamado ' Homestead.yaml'. Você pode
considerar este arquivo como o cérebro do ambiente de desenvolvimento local, o seu 'laravel / herdade'.

Através deste arquivo, você pode instruir o servidor web local. Você pode mencionar o caminho da raiz de projeto.
Você pode decidir o nome do seu aplicativo local. Eu acho que é sempre prudente adotar o mesmo nome que você está
indo para usar em seu ambiente de produção. Suponha que a sua aplicação final no nível de produção será nomeado ' www.example.com
'; nesse caso, é bom usar o mesmo nome localmente de modo que você pode digitar http: // exemplo. com no seu browser
para testar o aplicativo localmente.

Antes de editar o arquivo 'Homestead.yaml', você pode fazer mais duas coisas. Em primeiro lugar, verificar a sua versão
'laravel / herdade' e se prazo necessário este comando: ' sudo compositor globais requerem laravel / herdade: v2.0.8' . Tente
manter sempre o mais recente. Verificá-lo na Internet. Em seguida, você pode executar este comando também: ' export PATH =
"~ / .composer / fornecedor / bin: $ PATH"'. Vai ajudá-lo a correr ' herdade' comando de qualquer lugar em seu sistema.

Agora você precisa editar o arquivo 'Homestead.yaml' para manter duas coisas importantes no lugar. O primeiro é o
provedor. Corre ' sudo gedit Homestead.yaml' comando para abrir o arquivo no editor de texto. Por padrão, você veria " provider:
VirtualBox' no seu arquivo. Assim você não precisa mudar isso. Em seguida, você verificar esta parte.

A segunda parte é muito importante. Por padrão, o arquivo 'Homestead.yaml' surge com esta pasta e local
de estrutura:

pastas:
- Mapa: ~ / Código

para: / home / vagabundo / Código

sites:
- Mapa: homestead.app
para: / home / vagabundo / Code / Laravel / public

10
Capítulo 2 ■ LaraveL herdade, o Virtual Box, e errante

Nós já instalou Laravel na pasta 'Code / test / blog' no ambiente de trabalho. Por isso, precisamos de acrescentar que nesta
seção da pasta e site em primeiro lugar.

pastas:
- Mapa: ~ / Código

para: / home / vagabundo / Código

- Mapa: ~ Desktop / Code / teste / blog


para: / home / vagabundo / Desktop / Código / test / blog

sites:
- Mapa: homestead.app
para: / home / vagabundo / Code / Laravel / public
- Mapa: test.app
para: / home / vagabundo / Desktop / Code / test / blog / público

As linhas adicionadas são marcados a vermelho. Por favor note que eu mencionei o caminho completo. Onde quer que você
mantenha sua aplicação Laravel, é preciso mencionar o caminho completo. Então, temos quase vir para o próximo.

Você provavelmente já percebeu que temos chamado nossa aplicação 'test.app'. Em seguida, você precisa adicionar os
“domínios” para seus sites locais para o arquivo 'hosts' na sua máquina. O arquivo 'hosts' irá redirecionar solicitações para seus sites
Homestead em sua máquina Homestead. No Mac e Linux, este arquivo está localizado em '/ etc / hosts'. Abra este arquivo no seu
editor de texto.

sudo gedit / etc / hosts /

Geralmente ele vem com duas linhas no topo. Você deve adicionar o seu 'test.app' após as duas linhas.

localhost 127.0.0.1 127.0.0.1 hagudu-H81M-S1 192.168.10.10


test.app

Tudo feito, agora você pode fogo até Vagrant e executar o seu site. Vá para a pasta Laravel ' cd /
Desktop / Code / teste / blog' e emitir o comando: ' Vagrant up'.
O terminal geralmente se parece com a imagem na Figura  3/2 . Ela pode parecer diferente
dependendo do seu sistema operacional.

11
Capítulo 2 ■ LaraveL herdade, o Virtual Box, e errante

Figura 2-3. O terminal após a emissão de 'vagabundo up' comando

Ele normalmente leva alguns segundos para aquecê-la. Dar-lhe esse tempo, e em seguida você pode digitar com segurança http://test.app

em seu navegador para ver a página de boas vindas Laravel.

Estar em sua pasta Laravel, você pode executar 'artesão php servir' comando para executar a mesma
aplicação. Nesse caso, você deve digitar http: // localhost: 8000 no seu browser.
No entanto, existem muitas diferenças com o servidor Homestead. Quando você executa Homestead você tem a
versão mais recente php que é php 7.
Olhe para a imagem seguinte. Eu simplesmente manteve o 'phpinfo) (' método no meu 'teste. home page Laravel
aplicativo'(Figura  2-4 ).

12
Capítulo 2 ■ LaraveL herdade, o Virtual Box, e errante

Figura 2-4. test.app correndo as informações php 7

Eu espero que você pode fazê-lo. Se por acaso se você está preso, não hesite em me cair uma linha em

sanjib12sinha@gmail.com . Eu definitivamente vou tentar ajudar.

13
CAPÍTULO 3

Estrutura do arquivo

Vamos ver o que está dentro 'blog' na pasta Laravel instalado. Tem pastas como 'app', 'inicialização', 'config', 'base de dados',
'recursos', 'armazenamento' 'público', 'testes', 'fornecedor', e mais alguns arquivos, incluindo um 'compositor arquivo .json'.

Vamos primeiro ver como a estrutura do arquivo parece (Figura  1/3 ).

Figura 3-1. Laravel estrutura 5.3.18 arquivo

Como você vê, cada pasta e seus arquivos incluídos têm seus próprios papéis claramente definidos. Você não deve tentar
alterar ou ajustar qualquer código-fonte.
A pasta 'app' é extremamente importante. Ele tem, mais uma vez, muitas pastas importantes dentro. Atualmente, nós vamos
olhar para a frente para a pasta 'http' que tem controladores, middleware, modelos, eo arquivo 'routes.php'. Na verdade, nós colocamos
a nossa lógica de negócios nesta pasta por meio de rota e controladores. Ele ajuda-nos a manter o padrão de design orientado a
objeto de baixo acoplamento.

© Sanjib Sinha 2017 15


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_3
Capítulo 3 ■ estrutura de arquivo

A pasta 'inicialização' é necessário para o arranque do Laravel, e você precisa pasta 'config' para muitos arquivos
de configuração. Como um programador PHP, você sabe que a configuração de sessão ou configuração de autenticação
é importante. Laravel administra-lo através desta pasta 'config'.

O papel da pasta de base de dados também é muito vital para migrações e sementes, que nós discutiremos mais tarde em
grande detalhe. Atualmente, você pode pensar de migrações de banco de dados como arquivos PHP que escrevem códigos SQL e
executar operações de banco de dados diretamente em seu aplicativo. Você não precisa ir a qualquer interface do MySQL como o
phpMyAdmin. Você escrever códigos PHP e através da linha de comando Laravel você pode executar operações de banco de dados.
Você pode preencher as tabelas com dados, manipulá-los em conformidade. Eu acho que é uma das maiores características do
Laravel.

No ' público' pasta temos arquivos que estão disponíveis publicamente:'. htaccess', 'robots.txt', 'Favicon.ico', e index.php'. Esses
arquivos têm um papel importante em manter seu projeto em motores de busca. O ' Recursos' pasta tem a importante
sub-pastas como 'Vistas', onde seus códigos PHP / HTML visíveis são armazenados. Em 'armazenamento', cache e
arquivos de log são mantidos, e pasta os 'testes' é exclusivamente para testes de unidade. Finalmente, você encontra o ' fornecedor'
pasta novamente aqui, mas é só para os pacotes de terceiros que Laravel usa.

Encorajo-vos a entrar em cada pasta, abra todos os arquivos, e ver como eles são escritos. Você só lembrar de
uma coisa: nunca mudam qualquer código-fonte.
Nossa instalação Laravel está completa. Nós já instalou-lo pela primeira vez no '/ var / www / html /
MyFirstLaravelProject / blog' pasta. Em seguida, instalá-lo em '/ Desktop / Code / teste / blog' pasta. A primeira será utilizada
para as operações da base de dados e o segundo MySQL uma irá ser utilizado para operações de bases de dados SQLite.

Tudo o que agora precisa ver é que ele funciona perfeitamente. Vamos a primeira. Abra seu terminal e escrever
o seguinte:

cd / var / www / html / MyFirstLaravelProject / blog

Atingimos nosso projeto Laravel. Agora emitir este comando:

php artesão servir

Ele vai iniciar o servidor ambiente de desenvolvimento local de modo que se você abrir seu navegador e
digite http: // localhost: 8000 , ele vai abrir a página inicial de seu projeto Laravel.

Deve olhar como este (Figura  3-2 ):

16
Capítulo 3 ■ estrutura de arquivo

Figura 3-2. 5.3.18 home page Laravel

Todos os navegadores costumam dar saída HTML simples. Nesse sentido, deve haver alguns códigos HTML escondidos
em algum lugar no nosso projeto Laravel.
no capítulo 4 , Vamos ver como podemos mudar esta saída HTML. Além disso, vamos muito
discutir brevemente alguns pontos da pasta 'vistas', onde nós realmente precisam armazenar estes códigos HTML.

Mais tarde no livro, nos 'pontos de vista e lâminas' capítulo, vamos aprendê-la em detalhe.

3.1 SOLID princípio de design


Sim, isso é uma coisa muito avançado que você precisa aprender melhor de antemão. De Laravel 4 o princípio
design sólido foi mantida, e em Laravel 5 torna-se mais familiar para que você possa evitar a codificação duro e
escrever códigos mais limpos. Vamos ver o que este princípio de design sólido é.

Este livro não é o lugar para apresentar uma descrição detalhada do princípio SOLID. Mas pelo menos
podemos apresentar algo sobre isso em poucas palavras.
SOLID consiste nos cinco princípios de design articuladas por Robert “Tio Bob” Martin. Aqui eles estão em
breve, um por um. Na parte final vou discutir isso em detalhes, e espero que por esse tempo que você vai ter se
familiarizar com os princípios básicos da lógica da aplicação Laravel.

17
Capítulo 3 ■ estrutura de arquivo

arquibancadas sólida para

1) Princípio da responsabilidade única

2) Abrir Princípio Closed

3) Substituição de Liskov

4) Interface Princípio Segregação

5) Dependência Princípio Inversão

A Responsabilidade Individual princípio significa uma classe deve ter um, e eu quero dizer uma só,
razão para mudar. Limitar o conhecimento da classe é importante. O âmbito da classe deve ser
estritamente focado. Uma classe iria fazer o seu trabalho e não ser afetado em tudo pela mudança que
ocorre em suas dependências. Lembre-se, se é que podemos construir uma biblioteca de classes
pequenas com responsabilidades bem definidas, o nosso código será mais desacoplado e fácil de testar e
correr. The Open Princípio Fechado significa uma classe está sempre aberto para extensão, mas fechado
para modificação. Como é isso? Nada, exceto que quaisquer alterações ao comportamento deve ser feita
sem modificação dos códigos-fonte. Se você pode fazer o seu trabalho sem tocar no código fonte, então
você está seguindo o Aberto Princípio Fechado! Lembre-se que o tio Bob diz:

Mas se você pode planejar sua aplicação no início baseado em Abrir Princípio fechado, você pode modificar
sua base de código, o mais rapidamente possível sem ser afetado. Qual é a substituição de Liskov? Não fique
assustado. Isso parece intimidante, mas como um princípio, é extremamente útil e fácil de entender. Ele diz: Classes
derivadas devem ser substituíveis por sua classe base. Isso significa que os objetos devem ser substituídas com
instâncias de seus subtipos sem alterar a correção do programa. Se você não pode seguir que, apenas seguir em
frente; Vou explicar estes princípios em detalhe com exemplos e screenshots, para que a imagem será muito mais
clara.

A Interface Segregação Princípio é um eco de Responsabilidades singular. Se ele está quebrado,


Responsabilidade Singular está quebrado. Em poucas palavras, ele diz que a interface é granular e focado. Nenhuma
implementação da interface deve ser forçado em métodos que não usam. Assim, entrar em pequenas interfaces de como
você precisar deles para sua implementação. Planejar isso antes e desfrutar do passeio easy-going dissociado.

Finalmente, a inversão de dependência Princípio afirma que os códigos de alto nível não deve depender de códigos
de baixo nível. Em vez disso o código de alto nível depende de 'abstração' que atua como um meio-homem entre alto nível e
baixo nível. O segundo aspecto é que a abstração não depende de detalhes, mas os detalhes dependem de abstrações.
Para os iniciantes, estes princípios podem parecer não é confortável o suficiente, mas não se preocupe, pois vamos discutir
isso em detalhe com exemplos; por esse tempo você terá ganho confiança suficiente para fazer face a esta linguagem
conceitual. Você já encontrou os termos “Interface” e “Abstração” mais de uma vez, talvez muitas vezes, ser um candidato
merecedor de discussão. Então, vamos passar algum tempo com esses termos onipresentes que tantas vezes se deparar
em nossa aplicação Laravel.

18
Capítulo 3 ■ estrutura de arquivo

3.2 Interfaces e Método de Injecção


Abstração em OOP envolve extração de detalhes relevantes. Considere o papel de um vendedor de carros. Existem muitos
tipos de consumidor. Todo mundo quer comprar um carro, sem dúvida, mas cada um tem critérios diferentes. Cada um deles
está interessado em um ou dois certas características. Este atributo varia em conformidade. Forma, cor, potência do motor,
direção hidráulica, preço ... a lista é interminável. O vendedor conhece todos os detalhes do carro, mas ele repetir a lista um
por um até que alguém encontre sua escolha? Não. Ele apresenta apenas as informações relevantes para o cliente potencial.
Como resultado das práticas vendedor “Abstração” e apresenta apenas informações relevantes para o cliente.

Agora considere abstração a partir da perspectiva de um programador que queira um usuário para adicionar itens à lista.
faz abstração não significa que a informação não está disponível, mas ela garante que a informação relevante é fornecida para
o usuário.
PHP 5 introduz métodos e classes abstratos. Classes definidas como sumário não pode ser instanciada e qualquer
classe que contém, pelo menos, um método resumo também deve ser abstracto. Lembre-se que métodos abstratos não
pode definir a implementação. Por outro lado, interfaces de objetos permitem que você criar um código que especifica
quais métodos de uma classe deve implementar, sem ter que definir como esses métodos são manipulados.

As interfaces são definidos com a palavra-chave de interface, da mesma forma como uma classe padrão, mas sem
qualquer um dos métodos de ter os seus conteúdos definidos.
Todos os métodos declarados em uma interface deve ser pública; esta é a natureza de uma interface. Eu tenho
um fundo .NET e encontrou o uso de interfaces de lá quase onipresente. E em Laravel, a injeção de interfaces para as
classes é visto com freqüência, então é melhor você se familiarizar com o fundo conceitual.

Em Laravel interface é considerado como um contrato.


Contrato entre quem? E porque? Porque uma interface não contém qualquer código, mas só define um conjunto de
métodos que um objecto implementa. Dito isto, espero que agora você entender que eles estão interligados. Nós conversamos
sobre a manutenção de uma biblioteca de classes pequenas com escopos claramente definidos, e isso é possível com a ajuda de
Interfaces. À medida que o livro avança, você vai encontrar um monte de exemplos de Interfaces, então não se preocupe, você
vai encontrar estas duas palavras bastante freqüência nos exemplos. Até então, ter paciência e continue a ler.

Para uma imagem clara, eu gostaria de dar um pequeno exemplo para que possamos compreender essa propriedade do

comportamento do contrato encapsulada de interface rapidamente.

Vamos imaginar que tenho uma pasta 'Connection' dentro de uma pasta chamada 'Bengaliana' em que eu tenho
uma classe de conexão que nos conectar à 'Sanjib' banco de dados e recuperar alguns dados do 'utilizadores' os
respectivos quadros e 'tarefas'.
Eu não quero fazer o 'ConnectionClass' conhecer a nossa meta dados. Tudo o que vai fazer é só pegar a conexão e
recuperar a um atributo de uma tabela. O nome do atributo e mesa gostaria de fornecer dinamicamente para que a partir de um
método que pode recuperar muitos tipos de dados. Poderia ser nomes de usuário ou títulos tarefa simples, et cetera. Que
também estará de acordo com a natureza homomorphism dos nossos objetos.

19
Capítulo 3 ■ estrutura de arquivo

Em Laravel 5, como documento diz, todos os principais componentes implementar interfaces que estão localizados
no repositório dos iluminam / contratos '. Este repositório tem nenhuma dependência externa. Ter um conjunto
centralizado de interfaces torná-lo livre para usar as classes dissociados opcionais alternativas e fazer alguma injeção de
dependência mais livremente sem Laravel Fachadas. Ele define suas escolhas mais aberta e amigável. Bem, há uma
série de novas equipes que você vai encontrar como você progride e os novos recursos vão tornar a sua viagem
absolutamente agradável. Para citar alguns, há Route Cache, Middleware, método de controle de injeção, e muitos mais.

Em Laravel 5, autenticação de usuários se torna mais fácil, e o registro de usuário, autenticação e controladores de
redefinição de senha agora estão incluídos fora da caixa para que eles possam ser facilmente utilizado. Ok, introdução
suficiente. Agora é hora de pegar os artesãos web e fazer alguns códigos para que possamos fazer algumas aplicações
impressionantes no futuro.

20
CAPÍTULO 4

Routing, um método estático

O roteamento é o conceito de criação de um novo URI como http: // localhost: 8000 / Olá . Ele irá levá-lo para uma página
web de destino. Laravel torna extremamente simples. É um método estático que aceita duas coisas: um URI e uma função
anônima ou encerramento.
No ' app / HTTP / routes.php' ele foi definido principalmente. Comece o seu editor de texto favorito e abra o
arquivo. O que você vê?
Você vê algum código como este:

Route :: get ( '/', function () {


voltar view ( 'bem-vindo'); });

Aqui 'Route' é uma classe que tem um método estático 'get' que retorna um método 'view' que apresenta uma página web.
Quando um usuário visita a página inicial ele é levado para a página de 'bem-vindo'. Este 'bem-vindo' é na verdade um arquivo PHP:
' welcome.blade.php'. Ele foi armazenado por padrão na pasta 'vistas', enquanto nós tínhamos vindo a instalar Laravel. Quando
discutimos o conceito de 'visão' e motor de modelo 'lâmina' você vai entender completamente o que está acontecendo na camada de
apresentação.

Usando o protocolo HTTP você pode enviar outro pedido em vez da rota padrão.

Route :: get ( '/', function () {


retorno 'bem-vindo; });

Ele simplesmente irá retornar a palavra 'bem-vindo em sua home page. Experimente ou qualquer outra coisa. Olhe para o
código; existe uma função anônima também. Como um programador PHP Eu suponho que você sabe sobre função anônima ou
encerramento. É uma função muito útil, muitas vezes, usar na construção de aplicações. Laravel também usa este conceito.

Agora nós ainda não definimos a nossa rota, por isso, se nós batemos o navegador no URL http: // localhost: 8000 / Olá vamos
ter uma página de erro. Por isso, vamos criá-lo primeiro. Ir para as 'rotas. arquivo e php' adicionar este código:

// solicitando uma nova página


Route :: get ( '/ Olá', function () {
echo '<h1> Hello </ h1>'; });

© Sanjib Sinha 2017 21


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_4

www.allitebooks.com
Capítulo 4 ■ roteamento, um método estático

Vamos ver como ele olha e se nós podemos adicionar qualquer novo código HTML para ela, para mudar o visual.

Principalmente, parece que isso (veja a Figura  4-1 ):

Figura 4-1. encaminhamento para http: // localhost: 8000 / Olá URL

Agora nós gostaríamos de adicionar mais estilo CSS para ele. I alterar o código anterior a este:

// solicitando uma nova página


Route :: get ( '/ Olá', function () {
echo "<html>"
"<Head> <title> Laravel </ title>
<Style>
html, body {
altura: 100%; }
Body {

margem de: 0;
padding: 0; largura:
100%; display: mesa;

22
Capítulo 4 ■ roteamento, um método estático

fonte de peso: 100; fonte de


tamanho: 20 p; font-family:
'Lato'; }

. recipiente {
text-align: center; display:-célula
da tabela; vertical-align: meio; }

. conteúdo {
text-align: center; display:
inline-bloco; }

. título {
fonte de tamanho: 110px; } </
Style> </ head> <body>

<Div class = 'recipiente'>


<Div class = 'content'>
<Div class = 'title'> Olá, caro leitor </ div> <div class =
'recipiente'>
<Div class = 'content'> Como você está? Eu espero que você amaria este
livro! </ Div> </ div> </ div> </ div> </ body>" "</ html>";});

Este código é muito grande. É porque eu adicionei um estilo CSS pequena para ele. Você não precisa escrever esse
código. Basta tentar entender o poder deste pequeno arquivo ' routes.php'. Você pode virtualmente adicionar qualquer
funcionalidade em seu aplicativo através deste arquivo. Mas nunca fazer isso. O arquivo 'routes.php' não é para isso. Laravel
fez lugares separados para colocar seus estilos CSS e páginas HTML. Vamos ver a ele mais tarde em detalhe. Pouco antes
que nós só queria brincar com ele.

Agora parece completamente diferente no seu browser. Basta dar uma olhada (veja a Figura  4-2 ):

23
Capítulo 4 ■ roteamento, um método estático

Figura 4-2. encaminhamento para http: // localhost: 8000 / Olá URL

Com um novo estilo CSS parece muito especial. Mais tarde, vamos dar a mesma saída usando o motor modelo
'lâmina' de Laravel.
Agora, roteamento tem muitas outras funções importantes. Vamos considerá-los um por um. Em primeiro
lugar, podemos adicionar parâmetro rota e passar dados através da URL. É algo como você tem um http: //
localhost: 8000 / Olá página e quer dizer 'Olá' para o seu amigo. Laravel administra-lo muito bem. Através da
função anônima podemos passar este parâmetro, como http: // localhost: 8000 / Olá / leitor e a saída será 'Olá
leitor.' Vamos ver como podemos fazer isso.

Adicione este código ao seu 'routes.php':

Route :: get ( 'Olá / {name}', function ($ name) {


echo "Olá". $ Nome; });

Agora você pode passar todos os dados através da URL http: // localhost: 8000 / Olá / leitor
como parâmetro rota. Passei 'leitor', você pode passar quaisquer outros dados como você gosta.

Eu espero que você ter uma idéia básica como usar classe Route. Você também têm vindo a conhecer essa classe
Route tem alguns métodos estáticos como 'GET' e outros métodos. Através destes métodos classe Route ajudar o usuário a
alcançar seu destino URL.
Outros métodos de roteamento são assim:

Route :: get (); Route ::


pós (); Rota :: remendo
(); Route :: colocar ();

24
Capítulo 4 ■ roteamento, um método estático

Route :: delete (); Route ::


qualquer ();

I encontrar o ' qualquer()' método muito interessante. Você pode registar qualquer percurso que responde a quaisquer verbos HTTP
com este método.

Route :: qualquer ( 'qualquer', function () {


retornar "Tudo é possível se você tentar duro!"; });

Vamos para ' http: // localhost: 8000 / qualquer 'E ver esta saída simples.

4,1 Routing Melhores Práticas


Suponha que você deseja proteger a sua aplicação em toda a partir de cross-site request forgery (mais conhecido como CSRF). O
que você pode fazer? Existe algum comando único que pode emitir para proteger o nosso site a partir dos biscoitos "ou 'bandidos'?
Sim, existem. Vamos ver como podemos fazer isso. Escrever este código em seu routes.php:

Route :: quando ( '*', 'csrf', [ 'post', 'put', 'remendo']);

Voila! Isto é tudo que você precisa para proteger seu site e da próxima vez que você lançar o seu aplicativo Laravel, ele
vai cuidar de todos os tipos de CSRF.
Especialmente em um aplicativo grande, onde muitos usuários colocar abundância de mensagens e seu servidor está ocupado,
esta é uma grande dor de cabeça. Mas espere um minuto. Há muitas coisas incomuns na classe 'Route'; deixe-me chamá-lo mágico,
esperando por nós para explorar.
Primeiro de tudo, vamos discutir sobre roteamento 'implícita' e 'explícita'. Se você tem experiência um 'CodeIgniter',
você provavelmente já viu casos de roteamento 'implícita'. Quando escrevemos assim:

Route :: controlador ( 'admin', 'AdminController');

Isso nos redireciona implicitamente a pasta 'View / admin' a 'AdminController'. Ok, você é novo para o conceito de
controladores, mas não se preocupe: no próximo capítulo vamos abordar todos os funcionários controlador, então continue
a ler. Eu sugiro que você reler este capítulo posterior para entender a magia melhor.

A questão é a seguinte: podemos explicitamente 'rota' isso? Sim, nós podemos. Deixa-nos tentar:

Route :: get ( 'test / test', 'HomeController @ showTest'); Route :: get ( 'home / index',
'HomeController @ showIndex'); Route :: get ( 'home / about', 'HomeController @ Sobre'); Route
:: get ( 'home / contact', 'HomeController @ showContact'); Route :: get ( 'formação / php php em
Calcutá', 'PhpController @ showIndex'); Route :: get ( 'php / variável e tipo de dados',
'PhpController @ phpFirstPage'); Route :: get ( '/ formação codeigniter codeigniter em Calcutá',
'CodeIgniterController @ showIndex');

25
Capítulo 4 ■ roteamento, um método estático

Route :: get ( 'codeigniter / como começar codeigniter', 'CodeIgniterController @ CIFirstPage');

Route :: get ( 'wordpress / como começar wordpress', 'WpController @ showIndex');

Deixe-me pegar a última linha:

Route :: get ( 'wordpress / como começar wordpress', 'WpController @ showIndex');

Ele diz: na pasta 'View / wordpress', temos uma página como 'start-wordpress how-to-. blade.php' e nosso
controlador 'WpController' tem uma função pública chamada 'showIndex', que tem algo dentro dela para que o nosso
ponto final é 'como iniciar wordpress.blade.php'.
Agora, a questão é a seguinte: podemos grupo esta longa lista de encaminhamento controlador? Sim, temos uma
ferramenta útil chamado Route :: grupo (). Suponha que estamos apenas preocupados com os controladores 'home'. Podemos
agrupar-lo; sem problemas. Toda a lâmina de 'casa' pode vir sob um grupo como este:

Route :: grupo ([ 'prefixo'] => 'casa', function () {

Route :: get ( '/', 'HomeController @ showIndex'); Route :: get (


'/ about', 'HomeController @ Sobre'); Route :: get ( '/ contact',

'HomeController @ showContact'); });

Você vê, dentro do grupo, não precisamos escrever 'casa' mais. É expressamente dito para nosso roteador. Na linha
de comando você pode sempre verificar como seu trabalho está a avançar através deste comando:

rotas artesanais php

Em última análise, ele mostra todos os controladores que tenho usado no meu arquivo 'routes.php' e escritas antes. Para se apossar

de todos os controladores 'casa' que podemos fazer outra coisa. Considerando que 'casa' como o meu 'recurso' Eu posso escrever assim:

Route :: recurso ( 'home', 'HomeController');

Há mais por vir. Outra prática recomendada é 'nomear uma rota'.

4.2 rotas nomeadas


Suponha que você tenha uma página de login e você vai usar sessão para realizar a tarefa. Agora, para começar, podemos
escrever como este para chegar a nossa página de login:

// exemplo de rotas nomeadas Route :: get (


'/', function () {
voltar link_to_route ( 'sessão / criar', 'Login'); });

26
Capítulo 4 ■ roteamento, um método estático

Podemos escrever a mesma rota usando nossos controladores assim:

Route :: get ( 'sessão / criar', 'SessionController @ criar');

Mas todos estes são procedimentos normais que temos visto antes. Então, você pode ter pedido, onde é a
rota nomeada?
Ok, aqui está:

Route :: get ( 'sessão / criar', [ 'como' => 'criar', 'use' =>


'SessionController @ criar']); //equivalente a

Route :: get ( '/', function () {


retornar rota ( 'criar'); });

E há um monte de pessoal ainda está esperando por você. É a sua preferência que você teria usado, como a
escolha é sua.

Route :: get ( 'registrar', [


'Antes' => [ 'convidado']
'como' => [ 'registrar'],
'Uso' => [ 'SessionController @ registo']]);

Você pode escrever assim também:

Route :: get ( 'registrar', [


'Como' => [ 'registrar'],
'Uso' => [ 'SessionController @ registo']]) -> antes (
'guest');

4.3 Organizar arquivos através de Rota


Sim, você pode organizar seus arquivos através de sua rota. E às vezes isso pode ser muito útil. Suponha que você tenha
uma estrutura de pastas como este:

app / rotas / app admin.php /


rotas / login.php app / rotas /
register.php

Agora podemos declarar esta estrutura em sua 'routes.php' em um único comando como este:

(File :: AllFiles (_DIR_, '/ rotas') como $ parcial)


{
require_once $ parcial-> getPathname; }

27
Capítulo 4 ■ roteamento, um método estático

4,4 conceito avançado de Routing e


anónimos Funções
Ser capaz de definir a sua própria função por si mesmo é uma grande coisa que você pode fazer como um programador, e
você tem que fazê-lo no decorrer do desenvolvimento de uma aplicação. Em Laravel vimos o conceito de encerramentos. O
que é isso? programadores experientes sabem disso muito bem, mas para os novatos que requer alguma explicação. Isso
não é nada, mas chamou uma função anônima. É também chamado de 'lambdas'. Uma função anônima é nada, mas uma
função sem um nome.

Olá $ = function ($ name) {echo


“Olá”. $ Nome; }

Olá $ ( 'Mundo'); // output: Olá Mundo

Esta não é uma loucura; é claro que tem propósito. Muitas funções em PHP assumir funções como argumentos,
para que ele vem para ajudar nessas situações.
Considere uma situação como esta:

função yourName ($ value) {// fazer


alguma coisa}

array_map ( 'yourName', $ names);

Mas em vez disso, basta usar uma função anônima em linha e definir assim:

array_map (function ($ value) {// fazer


alguma coisa com $ value}, $ names)

Finalmente, uma função anônima pode ser usado como fechamentos em PHP, um conceito bastante avançado, mas
menos comum em PHP; É muito frequentemente utilizado em JavaScript. E em Laravel você já encontrou na usabilidade de
nível via de uma função anônima.

Route :: get ( '/', function () {return 'Olá


mundo!'});

28
CAPÍTULO 5

controlador Classe

No controlador de framework MVC tem um papel definido. Ele controla principalmente o fluxo entre o modelo e vista. No
arquivo 'routes.php' nós vimos como nos enviar o pedido através do protocolo HTTP. Agora queremos organizar o mesmo
comportamento usando a classe controlador.
Lembremo-nos o primeiro método de rota. Quando você instala Laravel que normalmente vem com este método
rota padrão.

Route :: get ( '/', function () {


voltar view ( 'bem-vindo'); });

Neste método rota temos uma visão. Como o método de rota diz: voltar a vista. A pergunta é: onde estão os modelos e
controladores? Não é suposto para criar apenas exibições usando um Encerramento, somos nós?

Suponha que temos 100 páginas em nossa aplicação. Nós não podemos fazer uma rota para cada página. Não podemos
colocar todos os nossos códigos HTML e CSS no arquivo 'routes.php'. Que o design é simplesmente feio e impensável. Não devemos
colocar a nossa lógica da aplicação no arquivo 'routes.php' quer. Para resolver este problema, o conceito de classe de controlador
entra em cena.
Controlador significa controlar a aplicação. É bastante literal: ele controla ou administra as camadas de aplicação.
Quais são as camadas?
Uma aplicação bem concebido sempre tem algumas camadas escondidas, interiores. Os usuários não devem obter qualquer indício

disso. Todos eles devem ver é a camada de apresentação. lógica de aplicação deve sempre ficar escondido.

Como um novato, você deve se acostumar a esta divisão camada. Um bom orientada a objetos sentido
programação será sempre orientá-lo para separar a lógica de aplicação da lógica de apresentação.

Um controlador é um transportador. Ele transporta a lógica da aplicação para a camada de apresentação. Um princípio de
design bom incentiva sempre que você escrever a lógica do aplicativo em um arquivo oculto separado. Um controlador só irá
executar esses métodos e retornar uma vista. Isso nunca vai saber o que ele carrega.

Para começar vamos criar rapidamente um controlador. É uma boa prática que você deve planejar-lo primeiro.
Suponha que você queira fazer um controlador simples que só irá retornar uma vista. Que tal dar um nome ' MyController
'? Mantemos este controlador em ' app / HTTP / Controladores pasta.

© Sanjib Sinha 2017 29


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_5
capítulo 5 ■ controlador Classe

Aqui está o código do nosso arquivo MyController.php:

<? Php
namespace App \ Http \ Controllers; usar
Illuminate \ Http \ Request; usar o App \ Http \
Requests;

classe MyController estende controlador {

// retornando uma página simples usando vista função


pública returningASimplePage () {
regresso vista ( 'newpage'); }}

Eu escrevi este código manualmente no meu editor de texto. Na verdade, você pode criar qualquer controlador
automaticamente através de linha de comando usando ' artesão' comando. Vamos aprender sobre ' artesão' comando em detalhe
mais tarde. Depois disso vamos também aprender sobre modelos e pontos de vista e conectá-los em conjunto para obter uma
compreensão total de modelo, vista, fluxo controlador. De fato, mais tarde você vai encontrar mais usos do ' artesão' comando na
criação de migrações de banco de dados, controladores, modelos e muitos mais. Basta ir para a pasta Laravel e emitir este
comando: artesão php. Então, observar a saída.

Agora é hora de usar este controlador em nossa " routes.php' Arquivo. Até agora, só temos usado encaminhamento para ir para a

página de visualização. A página de visualização é na verdade uma camada de apresentação. Vamos pensar em uma maneira orientada a

objetos.

Pela primeira vez vamos usar algo diferente: um controlador. Nos 'rotas. arquivo php' nós adicionar este
código:

Route :: get ( 'newpage', 'MyController @ returningASimplePage');

Vamos entender esta palavra linha por palavra. A primeira parte é bastante bem. classe de rota utiliza um
método estático dando uma URL: ' nova página'. Na segunda parte, escreva o nome do controlador 'MyController' e
usar um sinal especial '@' para chamar a função
'ReturningASimplePage'.
Se você voltar atrás e dar uma olhada no seu código MyController você verá que esta função
'returningASimplePage' simplesmente retorna um 'newpage'. Nós já armazenou esta ' newpage.blade.php' arquivo em
nossa 'vistas' pasta antes. Eu não quero dar código HTML tanto tempo. É quase o mesmo que o código HTML que tinha
usado em nosso arquivo 'routes.php' antes.

Agora podemos escrever http: // localhost: 8000 / newpage para ver o que ele mostra! (Figura  5-1 .)

30
capítulo 5 ■ controlador Classe

Figura 5-1. A exibição de página simples através de um controlador simples

É uma saída pouco agradável e temos produzido esta saída de um controlador. Temos progredido um
pouco!
Como você acabou de ver na ' MyController.php' arquivo, é uma classe. Ele deve ter uma função pública; caso contrário,
Laravel não pode encaminhá-lo.
Ao escrever uma classe de controlador é preciso lembrar algumas coisas. Primeiro, nós renderizar uma visão usando

uma classe de controlador sempre usando funções públicas.

índice da função pública () {


voltar view ( 'home'); }

Em segundo lugar, na 'Routes.php' arquivo, não usamos mais a função anônima ou encerramento. Nós rota do
controlador em seu lugar.

Route :: get ( 'home', 'MyController @ index');

Nesta primeira parte da classe do controlador, não estamos mergulho muito profundo. Vamos primeiro ver como modelo e
trabalho vista em uníssono com uma classe de controlador. Depois disso, na segunda parte da classe do controlador, veremos mais
funcionalidade e tentar construir uma aplicação databaseoriented dinâmico.

31
capítulo 5 ■ controlador Classe

5.1 Controlador RESTful


Antes de iniciar este capítulo, vamos perceber uma coisa. RESTO (Representational State Transfer) é um um protocolo de
arquitectura através do qual nós imaginamos nossas URLs como substantivos e dar-lhes verbos comuns como GET, POST,
PUT ou DELETE. Cada URL é uma representação de um recurso imaginário. Espero que eu possa discutir este tópico
interessante na sequela a este básico livro Laravel Learner. Como eu usei esse termo antes, eu suponho que você já se
tornaram familiarizados com o termo 'RESTful'. O que isso significa? Em um sentido mais simples que oferece algumas
soluções. Quando rota para Closures podemos definir o verbo HTTP na forma método.

Route :: get ( 'index', 'cliente \ Profiling \ ProfileController @ showIndex');

Mas agora estamos preocupados com o controlador, por isso devemos ter uma solução para isso também. Assim,
'RESTful' vem em nosso socorro. Agora podemos dizer explicitamente o nosso mecanismo de transporte: que tipo de verbos
que devemos usar e como. Como podemos fazer isso? 'App / Contrllers / profile.php' pode ser escrito assim:

namespace Cliente \ Profiling;

classe ProfileController estende BaseController

função pública getProfile ()

retornar View :: fazer ( 'perfil');

}
postCreate função pública () {

// alguma forma aqui para coletar dados}}

Estes métodos poderiam ter sido mais. O número realmente não importa. Podemos acrescentar 'apagar' verbo também.
Agora em nossa 'routes.php' podemos usar todos esses verbos HTTP em um único comando como este:

Route :: controlador ( 'perfil', 'cliente \ Profiling \ ProfileController');

Através deste comando que pode encaminhar todos os verbos HTTP usados ​em sala de aula o 'ProfileController'. Nossa intenção
é bastante simples. Tentamos mostrar-se um formulário onde os usuários irão encher seus nomes e outros detalhes. Depois que
ocupam esses dados e publicá-las para o nosso banco de dados. Em Laravel 3.2, foi utilizado para escrevê-lo de forma diferente, mas o
'ficar' ou prefixos 'put' estão lá também.

32
capítulo 5 ■ controlador Classe

5.2 O papel de um controlador


A primeira pergunta é a seguinte: o que é um controlador? Como você viu nos exemplos dados até agora, não é nada, mas uma
espécie de mecanismo de transporte. Leva os usuários ou os telespectadores para a camada de apresentação. Lembramo-nos o
direito de que uma classe deve ter uma tarefa singular. A classe Controller leva você para a camada de apresentação e seu
trabalho deve ser concluído lá. Ele não deve saber o seu aplicativo ou lógica de domínio. Por que não? Porque é um mecanismo
de transporte, nada mais. É como um cabo de dados para um monitor de TV. Há uma abundância de outras coisas em sua
aplicação acontecendo em segundo plano, e você deve tomar cuidado com isso para que uma pessoa de fora não pode chegar
lá. Imagine uma situação como esta:

classe UserController estende BaseController {função pública


getIndex () {

$ Users = Usuário :: tudo ();


retornar View :: make ( 'users.index', compactas ( 'utilizadores')); }}

Este 'User :: tudo ()' refere-se a proposição Eloquent ORM. Não se preocupe, vamos chegar a esse capítulo muito em breve na
parte de banco de dados e discutir sobre 'Eloquent ORM' em grande detalhe. Atualmente você precisa saber apenas que mantém
contato com a camada de dados. Agora, devemos conectar ao banco de dados diretamente de nossos controladores? Se um mecanismo
de transporte que é suposto para se comunicar com a nossa camada de apresentação também conversar com a camada de dados? A
camada de dados é um ponto vulnerável, e ele vai nos colocar em uma situação difícil se alguém coloca alguns códigos sujas para ele.
Lembre-se, o controlador é um portador, por isso vai levá-lo de volta para a camada de dados e nós vamos ter que enfrentar a bagunça!

Então, é melhor mantê-lo no escuro sobre a lógica de domínio ou camada de dados e fazer o seu trabalho singular,
dissociando-o de uma forma adequada para a nossa aplicação. Como podemos fazer isso? Aqui, Interface vem em nosso
socorro: uma grande coisa, na verdade. No capítulo Interfaces falamos sobre voltar a ele, e por isso aqui estamos
novamente. Interfaces pode nos salvar, encapsulando a lógica real. Nós estamos seguros. Como não quer bater o banco de
dados diretamente de nossa classe Controller, mantemos um escudo entre eles, ou seja, Interfaces. Ele irá actuar como um
meio entre Eloquent ORM e controlador. Nosso controlador nunca vai saber de onde vem os dados. Ele vai fazer o seu
trabalho e esquecê-la. Tem muitas vantagens como classes abstratas. Mas há uma diferença sutil entre eles. Uma interface
define o contrato sintática que todas as classes derivadas devem seguir. Especificamente, a interface define a parte 'o que'
do contrato sintática e as classes derivadas irá descrever a parte 'como' do contrato.

OrderDetails de interface {
função pública UpdateCustomerStatus (array $ user, $
quantidade); }

classe UserClass implementa OrderDetails {


função pública UpdateCustomerStatus (array $ user, $
quantidade) {
// fazer algo através Eloquent}}

33
capítulo 5 ■ controlador Classe

Você pode usar várias interfaces entre eles; não se preocupe com a usá-los em sua aplicação. Quanto mais
você usá-lo, melhor. Algumas pessoas podem opor-se à digitação extra, mas pessoalmente eu acho que o uso de
interfaces iria fazer a sua aplicação mais robusta e ágil. Você pode testá-los sem bater a sua lógica de domínio
da sua camada web.

5,3 Controlador Versátil


controlador engenhoso é uma das maiores novas equipes controlador que Laravel 4 vem com. O método de recurso
de classe de controlador, por vezes, pode fazer a mágica para nós, e vamos ver como ele acontece! Vamos dar uma
olhada no meu comando artesão e descobrir se há alguma coisa sobre o pessoal Controller. Digite o seguinte:

php -list artesão

E vemos um controlador: tornar método para tornar um controlador de recursos. Muito bom descobriram que
em uma linha muito melhorada comando php artesão podemos fazer controlador engenhoso.

Vamos criar um controlador de recursos usando o comando artesão php e ver o que acontece. Nós podemos
emitir o comando como este:

php controlador de artesão: fazer UserController

Agora, se nós deixá-lo assim, ele irá criar um controlador de recursos na pasta controlador do meu projeto. O céu é o
limite para o que você pode fazer com seu UserController controlador engenhoso. Você pode mostrar qualquer usuário com o
seu ID, você pode editar, atualizar e criar, e até mesmo destruir ou apagar os registros. Atualmente estamos interessados ​nos
dois primeiros métodos, ou seja, índice e show ($ id). Vamos declarar um método novo Route :: recurso () em nosso arquivo
routes.php. É algo como isto:

Route :: recurso ( 'Sanjib', 'UserController',

[ 'Apenas' => [ 'índice', 'mapa']]);

Como você pode ver, podemos chamar o nosso recurso 'Sanjib' e esse recurso é tratado pelo
'UserController' e que só lida com o 'index' e o método 'show'.
Agora, se você digita http: // localhost: 8000 / Sanjib você vê uma boa saída de qualquer coisa que você retornar
de seu método index 'UserController'. E, além disso, se você digitar
http: // localhost: 8000 / Sanjib / 1 , ele vai te dar uma saída agradável com a passagem $ id, que é 1 aqui.

Portanto, este é um grande passo para a frente de Laravel 3, onde esta '$ id' passado como um método. Enfim, se
você escreve como Route :: recurso ( 'Sanjib', 'UserController'), ele irá produzir todos os sete métodos que acabo mostradas
você. E, finalmente, você pode criar, armazenar,

34
capítulo 5 ■ controlador Classe

editar, atualizar e excluir seus usuários contra esses métodos. Agora podemos anexar filtro para cada método único,
quer de uma só vez ou sozinho. Vamos fazer uma mudança em nosso código UserController, adicionando uma linha de
chamar filtro construtor como este:

//UserController.php
__construct função pública () {
$ This-> beforeFilter ( 'Sanjib'); }

E com ele vamos anexar filtro para todos os meus métodos de arquivo 'routes.php' assim:

Route :: filtro ( 'Sanjib', function () {


voltar 'Este filtro é anexado a todos os métodos de
Sanjib recurso'; });

Agora podemos restringir esse filtro para o único 'index' ou qualquer método que desejar. Isso também é um pedaço de
bolo agora. Se você quer anexá-lo ao 'index', basta escrever o seguinte:

__construct função pública () {


$ This-> beforeFilter ( 'Sanjib', [ 'apenas' => [ 'index']]); }

Dessa forma, único método 'index' é filtrado, nada mais. Espero que o papel de um controlador é bastante claro agora
e nós podemos fazer alguns ajustes com a dinâmica urbana página 'Ver' e ver como podemos controlar e passar nossos
dados através do controlador e construir um site simples.

5,4 Controlador, IOC recipiente, e interface


Até agora, temos falado muito sobre o que um controlador deve saber. Mas, você pode perguntar, onde está a sua
implementação? Exatamente! Isso é o que eu vou mostrar a você agora e esta é a beleza pura de Laravel 4.2 de abordagens
de código-feliz. E todos nós queremos ser código feliz, não é? Devemos ser capazes de escrever algum código decente: se
não estamos tão realizado como Taylor Otwell, pelo menos poderíamos tentar algumas coisas extravagantes que satisfizesse
a nossa estética nascida-in.

Por isso, vamos tentar algumas boas práticas. Como queríamos limitar o conhecimento de um controlador, vamos
implementar uma interface e fazer nosso controlador ignorante de quaisquer outras atividades, exceto o mecanismo de
transporte. Se dentro de nosso UserController que escrever algo como isto:

$ User = Usuário :: tudo ();


retornar View :: make ( 'user.index')
> com ( 'user', $ user);

35
capítulo 5 ■ controlador Classe

nosso controlador atinge diretamente o banco de dados. Que nós não queremos. Então o que podemos fazer em vez disso?

Vamos criar uma interface 'alluser' em nossa pasta modelo. O código é simples.

<? Php /
*
* esta interface recebe todos os usuários através de uma classe chamada
GetAllUsers
*/
AllUsers de interface {
getUsers função pública (); }

Esta interface irá funcionar como um contrato entre nossas classes 'GetAllUsers' e nosso controlador
'UserController'. Vamos criar uma classe 'GetAllUsers' como este:

<? Php /
*
* essa classe implementa a interface AllUsers e ligado em IoC
Container
*/
GetAllUsers classe implementa AllUsers {
getUsers função pública () {
$ Users = Usuário :: tudo (); retornar $
utilizadores; }}

Através desta classe nós recuperamos todos os nossos usuários dos usuários da tabela de banco de dados. Nós ainda não cobrem

vista, modelo, Eloquent ORM e banco de dados, então não se preocupe. Tudo que você precisa saber agora que temos uma tabela do

usuário dentro do nosso banco de dados e estamos recuperando todos os funcionários da tabela de usuários.

Agora, finalmente, como faz nosso controlador look 'UserController' como?

<? Php
classe UserController estende $ users \ BaseController
{protegidas;
função pública __construct (usuários AllUsers $) {

$ This> usuários = $ utilizadores; }

getUsers função pública () {


$ User = $ this> Usuários> getUsers ();
retornar View :: make ( 'user.index') -> com ( 'user', $ user); }

índice da função pública () {//

36
capítulo 5 ■ controlador Classe

}
função pública criar () {//}

loja de função pública () {//}

função pública show ($ id) {

//

}
editar função pública ($ id) {//}

atualização função pública ($ id) {//}

função pública destruir ($ id) {//}}

Esta parte é particularmente importante:

utilizadores $ protegidas;
função pública __construct (usuários AllUsers $) {

$ This> usuários = $ utilizadores; }

getUsers função pública () {$ user = $ this->


usuários-> getUsers ();
retornar View :: make ( 'user.index') -> com ( 'user', $ user);

Nós implementamos a interface e através de nossos 'GetAllUsers' classe finalmente chegamos toda a tabela de
usuários. Agora em 'index' Ver que acabamos de percorrer o objeto 'usuário' e extrair o 'username' como este:

foreach ($ user como valor R $) {


echo $ value> nome de usuário. "<br>"; }

37
capítulo 5 ■ controlador Classe

Agora, a lógica é clara e muito lúcida a seguir. Agora somos livres para mudar de alvo os dados a qualquer momento
mudando apenas dentro da classe ou a criação de uma outra classe. Aqui nós usamos 'mysql' mas podemos alterá-lo a qualquer
momento para qualquer banco de dados que desejar. A coisa mais importante é que o nosso controlador de nunca saber o que está
acontecendo lá dentro. Mas o corte final está dentro do nosso arquivo 'rota', porque nós temos que vincular a classe e a interface ea
grande contêiner IoC desempenha o papel essencial. Isto é muito simples com Fachadas seus 'PDA'. O código é a seguinte:

App :: bind ( 'AllUsers', 'GetAllUsers');

Como você vê, Fachadas nosso 'App' vincular a classe e interface de conjunto para que uma camada agradável foi
incluído entre a nossa fonte de dados e mecanismo de transporte. Além disso, nosso controlador não sabe sobre o que
vem acontecendo dentro daquela camada. Nossa aplicação se torna mais dissociado e testá-lo facilmente com 'phpunit'
sem bater diretamente o banco de dados.

5.5 Resumo
Nós normalmente organizar o nosso mecanismo de transporte ou camada web através de classe de controlador. Portanto, esta é uma
boa prática para torná-lo ignorante sobre nossas interfaces lógica de domínio e usar como um meio entre web e camada de dados.
Através de classes do controlador organizamos nossa lógica routelevel e, além disso, podemos usar os recursos modernos, como
injeção de dependência.
Usar interface e deixar controladores de manter a sua singularidade de trabalho que deve se preocupar apenas com a camada
web. Desde que nós usamos Composer para autoload nossas classes PHP, ele pode viver em qualquer lugar no sistema de arquivos,
enquanto controlador sabe sobre ele. E encaminhamento para o controlador é totalmente dissociado do sistema de arquivos.

controladores Versátil costumam fazer controlador RESTful em torno de recursos. Finalmente, podemos concluir
com a parte de filtro, que é extremamente importante na gestão da administração de um aplicativo. Você pode
controlá-lo através do nível das vias ou explicitamente usá-lo dentro de seu controlador.

Route :: get ( 'perfil', array ( 'antes' => 'auth', 'usa' =>


'UserController @ showProfile'));

Ou você pode especificamente mencioná-lo dentro do controlador:

Classe UserController estende BaseController {função pública


__construct () {

$ This-> beforeFilter ( 'auth', array ( 'exceção' => 'getLogin'));

$ This-> beforeFilter ( 'csrf', array ( 'on' => 'post'));

$ This-> afterFilter ( 'log', array ( 'apenas' => array (


'fooAction', 'barAction'))); }}

38
capítulo 5 ■ controlador Classe

E, finalmente filtro pode ser utilizado através do construtor como este:

classe UserController estende BaseController {função pública


__construct () {

$ This-> (função beforeFilter () {

// some code}); }}

Depois de dominar o controlador básico, é bom consultar a documentação oficial Laravel para aprimorar
suas habilidades.

39
CAPÍTULO 6

Ver e Blade

No framework MVC, a parte 'view' tem um papel importante. Antes de tudo, deve ser bom e atraente. Ele lida
com HTML, CSS, JavaScript, e muitos outros códigos que fazem uma página está ótima.

Neste momento um pouco de conhecimento é necessário. Você não precisa ser um especialista para aprender neste capítulo.
pasta 'Vistas' permanece pasta 'recursos' no interior. Você precisa manter seus códigos html aqui. Para fazer com que pareça incrível,
você pode desejar ter um grande estilo CSS! Esse arquivo CSS e outros arquivos JavaScript necessários deve ir a pasta dentro
'público'. Laravel conecta-los facilmente.

Aprenderemos esse processo passo a passo.

Primeiro vamos criar algumas páginas estáticas. Em segundo lugar, vamos passar dados dinâmicos para que possamos mais tarde

construir um aplicativo dinâmico no topo do que.

Suponha que nós queremos ter um 'Sobre' página em sua aplicação. Vamos criá-lo e conectá-lo ao nosso ' MyController'
e, finalmente, encaminhá-lo para o navegador.
É bastante natural que não vamos parar de ter apenas uma página estática. Mais tarde, pode precisar de uma página 'Fale
Conosco' ou qualquer número de outras páginas. Mantendo essa perspectiva em mente, vamos criar uma pasta pasta 'páginas' dentro
'vistas'. Na pasta 'páginas' primeiro criamos um
'Master.blade.php' Arquivo. Esta é uma página de layout mestre. Não é obrigatório que devemos sempre chamá-lo de
'mestre'. Podemos chamá-lo de ' layout.blade.php' ou ' default.blade.php' ou podemos escolher qualquer outro nome
significativo. Esta página mestre é um modelo de nosso layout básico que outras páginas vai seguir.

Lembre-se, você sempre pode criar pastas separadas para manter layouts mestre separados para outras páginas. É
escusado será dizer que você deve sempre ter apenas um layout mestre para toda a sua aplicação.

Vamos manter o nosso layout mestre bastante simples. Antes de ir para escrever os códigos, a gente pode querer aprender
uma coisa: o que significa o termo 'lâmina' significa?
Bem, 'lâmina' é o modelo de motor de Laravel e deve ser escrito em PHP. Ele tem suas próprias funções para tornar
a sua vida mais fácil. E por essa razão que você precisa para adicionar uma extensão de 'blade.php'.

Vamos escrever um simples código 'master.blade.php' e ele vai ter algumas funções de templates especiais
'Blade'.

//resources/views/pages/master.blade.php <! DOCTYPE


html> <html>

<Head>

© Sanjib Sinha 2017 41


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_6
Capítulo 6 ■ Ver e Blade

@yield ( 'cabeça')
<Link rel = 'stylesheet' href = '/ css / style.css'> <title>

@yield ( 'title') </


title> </ head> <body>

<Div class = "container">


<Div class = "heading">
@yield ( 'título') </ div>

<Div class = "content"> @yield


( 'conteúdo')
</ Div>
<Div class = "footer"> rendimento @ ( 'rodapé') </ div> </ div> </
body> </ html>

Como você vê, temos utilizado apenas uma função-' produção' -Dentro a página mestra. Nós
chamar essa função com um sinal de '@'. Esta função tem um significado literal. É realmente produz, produz
ou gera algo.
Nós segmentamos nossos códigos HTML em algumas partes, para que possam ser facilmente lembrado. Na parte
'cabeça' temos duas funções 'rendimento': 'cabeça' e 'title'. Sob o '@yield (' cabeça ')' função temos o nosso link de estilo
CSS ea função de outra 'rendimento' tem 'título' dentro dela. A parte restante segue as classes de divisão de estilo CSS. No
'título', mantemos um grande título ponto. Na parte de conteúdo temos definido ponto de corpo, estilo de fonte, et cetera.

Vamos ver o nosso código de estilo CSS que temos mantido na pasta 'public / css'.

html //public/css/style.css, body


{
altura: 100%; }

body {
margem: 10; enchimento:
10; largura: 90%; display:
compacto; fonte de peso:
100; font-family: 'Lato';
font-size: 22px; }

. recipiente {
text-align: left; display:-célula da
tabela; vertical-align: meio; }

42

www.allitebooks.com
Capítulo 6 ■ Ver e Blade

. conteúdo {
text-align: left; display:
inline-bloco; }

. rodapé {
text-align: right; display:
compacto; font-family: 'Lato';
fonte de tamanho: 14 px; cor
vermelha; }

. indo {
text-align: center;
fonte de tamanho: 136px;
text-height: max-size; Cor:
indianred; }

. h1 {
text-align: center; font-size:
66px; font-family: fantasia;
cor: de tomate; }

. h2 {
text-align: center; fonte de
tamanho: 46 pixels; font-family:
cursiva; Cor: coral; }

Até agora, definimos nosso arquivo 'master.blade.php' eo arquivo 'style.css'. Você deve ter notado que no
arquivo 'master.blade.php' na seção 'cabeça' damos o link estilo CSS. Agora existe uma opção onde você pode
colocar este link do arquivo CSS no seu 'sobre. página blade.php'.

Vamos primeiro escrever o arquivo 'about.blade.php'.

//resources/views/pages/about.blade.php @extends (
'pages.master') @section ( 'cabeça') @stop

@Título da seção')
É um @stop página de
teste
@section ( 'título')
{{$ Name}} {{$ profissão}} @stop

@section ( 'conteúdo') <div


class = 'h1>

43
Capítulo 6 ■ Ver e Blade

Toda escrita é um problema! </ Div>


<p>

Houve um problema poucos minutos atrás. Houve um problema poucos minutos atrás.

Houve um problema poucos minutos atrás. Houve um problema poucos minutos atrás.

Houve um problema poucos minutos atrás. </ P>

<Div class = 'h2>


Acabo resolveu. </ Div> <p>

Tenha um bom folks tempo. </ P>


@stop

@section ( 'rodapé')
Início de Sanjib Sinha @stop

No topo nós usamos a função 'estende', que literalmente se estende a modularidade da página mestre. Depois disso,
nós continuamente usar apenas duas funções: 'secção' e 'stop'. Estas funções realmente conectar com os estilos CSS que
você definiu anteriormente.
Cada seção tem sua própria divisão: 'cabeça', 'title', 'título', 'conteúdo' e 'rodapé'. Cada 'secção' contém seus próprios
conteúdos e, em seguida, usamos a função 'stop' para parar com isso 'secção'.
Dentro da seção 'cabeça' de 'master.blade.php', temos usado o link de estilo CSS. Você também pode usar o mesmo
link dentro do 'about.blade.php'. Nesse caso, você não precisa usar o link estilo CSS dentro do arquivo 'master.blade.php'. A
parte superior da nossa página 'about.blade.php' acaba por ser parecido com isto:

//resources/views/pages/about.blade.php @extends (
'pages.master') @section ( 'cabeça')

<link rel = 'stylesheet' href = '/ css / style.css'> @stop

Mas o uso de estilo CSS dentro 'master.blade.php' é sempre preferível. Agora, espero que você
pode fazer uma relação entre as funções de 'master. blade.php' e 'about.blade.php.' A página mestra
desempenha o papel de um pai e sobre a página é o seu filho. A lógica flui de pai para a criança.

No 'about.blade.php' encontramos dois termos estrangeiros na seção 'título':

//resources/views/pages/about.blade.php @section (
'título')
{{$ Name}} {{$ profissão}} @stop

44
Capítulo 6 ■ Ver e Blade

Você é inteligente o suficiente para adivinhar que eles são os nomes das variáveis ​que nós usamos em nosso
controlador. Caso contrário, como eles aparecem em nossos arquivos 'about.blade.php'? Nós não vimos-los à nossa página
mestra.
Você adivinhou certo: eles vêm a partir do controlador, ' MyController.php' Arquivo. Anteriormente, nós falamos sobre a
passagem de dados dinamicamente através do controlador da lâmina vista. Desde que é 'sobre' a página, podemos passar
algumas peças de dados interessantes sobre nós.
Decidimos passar por dois pontos de dados importantes através do controlador: 'nome' e 'profissão'. Vamos
ver o código MyController primeiro.

função pública //app/Http/Controllers/MyController.php


sobre () {
$ Name = 'John Doe'; $ Profissão =
'A Writer';
voltar view ( 'pages.about', compacto ( 'name', 'profissão')); }

Você vê que nós definimos duas variáveis ​primeiro e depois retornar essas variáveis ​usando o método 'view'
para o 'pages.about'. Aqui o termo 'páginas' refere-se ao nome da pasta
'Recursos / views / pages'. A segunda parte-'about'-se refere ao arquivo 'about.blade.php'. Poderíamos ter escrito isso
como ' páginas / about' em MyController. Mas eu, pessoalmente, prefiro o '' notação uma vez que reflecte a abordagem
orientada a objetos.
Esta passagem de dados pode ser feito usando muitos truques. Nós mostramos o método PHP 'compact'.
Mas poderia ter sido feito desta forma também.

função pública //app/Http/Controllers/MyController.php


sobre () {
$ Name = 'John Doe';
voltar view ( 'pages.about') -> com ( 'name', $ name); }

Ou poderíamos ter passado como um valor de array, e você pode passar uma matriz de longo desta forma.

função pública //app/Http/Controllers/MyController.php


sobre () {
voltar view ( 'pages.about') -> com ([
'Name' => 'John Doe', 'profissão'
=> 'Um Escritor']);

Finalmente, podemos verificar como ele olha em nosso navegador favorito. Tipo http: // localhost: 8000 / about e
abre a página (Figura  6-1 ).

45
Capítulo 6 ■ Ver e Blade

Figura 6-1. Nós passamos dados dinamicamente para ver

Até agora, nós aprendemos alguns truques que nos permitam criar páginas estáticas com alguns dados
gerados dinamicamente através do controlador.
Tendo progredido um pouco, nós ganhamos alguma confiança, e nós, provavelmente, pode aventurar-se agora para
assumir algumas tarefas mais difíceis.

46
CAPÍTULO 7

Meio Ambiente

Laravel vem com muitas características impressionantes. Um deles é definitivamente migrações de banco de dados. No
próximo capítulo vamos discutir a migração em detalhe.
Antes disso, precisamos entender o nosso ambiente corretamente. O que é ambiente em Laravel? Se você olhar para a
raiz do documento você encontrará um arquivo '.env'. Ele basicamente diz-nos sobre as conexões de banco de dados. Onde
poderíamos obter esse arquivo de instalação do banco de dados padrão? Na pasta 'config', temos um arquivo 'database.php'.
Abri-lo e ver o conteúdo.
Vemos uma linha que nos diz sobre a conexão banco de dados padrão.

//config/database.php
'Default' => env ( 'DB_CONNECTION', 'mysql'),

É MySQL. Nós não vamos mudá-lo por agora, embora seja temporária, porque na parte final do livro, vamos ver como
podemos trabalhar com banco de dados SQLite. Neste momento apenas mantê-lo como ele é - o nosso banco de dados padrão é
MySQL. Agora abrindo nosso arquivo '.env' somarmos nosso banco de dados, nome de usuário e senha.

//.env
DB_CONNECTION = mysql

DB_HOST = 127.0.0.1 DB_PORT =

3306 = DB_DATABASE TestDB

DB_USERNAME = raiz

DB_PASSWORD = passe

Mas há um problema, é claro. Suponha que gostaríamos de colocar nosso projeto em qualquer repositório nuvem como
"github. Nesse caso, os nossos segredos pode sair.
Laravel tenha pensado nisso. No '. gitignore' arquivo, ele já
adicionou esta linha:

//.gitignore /
fornecedor
/ Node_modules / public /
armazenamento
Homestead.yaml
Homestead.json
. env

© Sanjib Sinha 2017 47


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_7
Capítulo 7 ■ meio Ambiente

Quando você coloca todo o projeto, ele vai ignorar automaticamente as pastas listadas e arquivos.
Homestead.yaml e Homestead.json estão entre eles.
Nós criamos o nosso meio ambiente e, agora, podemos seguramente mover para nosso próximo grande capítulo: migrações de

banco de dados. Depois disso vamos discutir eloquente, e depois vamos finalmente ver como Modelo, Vista e Controlador de fluxo de

trabalho funciona. Também vamos ver como podemos “criar, recuperar, atualizar e excluir” nosso banco de dados SQLite.

48
CAPÍTULO 8

Migração de banco de dados

a migração do banco de dados é uma das melhores características que Laravel fornece. Como um novato, você pode encontrar
adquirir o conceito um pouco difícil. Mas uma vez que você aprendeu sobre a migração do banco de dados, a experiência de
trabalhar com qualquer tipo de banco de dados torna-se extremamente fácil e agradável.

No passado, você precisa criar um banco de dados, tabelas e colunas ou por codificação SQL ou usando uma
ferramenta como o phpMyAdmin. A tarefa parece ser assustadora às vezes. Com Laravel, ele não é mais difícil.

Além disso, temos uma vantagem extra. Como um desenvolvedor, trabalhando em uma equipe, você pode começar seu trabalho de

banco de dados bem sincronizados com os seus colegas. Nesse sentido é tornar-se como um controle de versão. Você pode facilmente rolar

para fora sua tabela de banco de dados e atualização com novas funcionalidades através de códigos php dentro de sua aplicação.

Tudo que você precisa fazer é escrever algumas linhas de código PHP e Laravel vai cuidar dos próximos passos. É simples assim.

Vamos começar com mesa de um simples 'tarefas'.

Já mencionamos os nomes de banco de dados e outro pessoal em nosso arquivo '.env'. Agora é hora de criar uma
tabela 'tarefa' e adicione algumas colunas a ele.
Antes de iniciar uma nova migração vamos ter com o nosso " database / migrações /' pasta; descobrimos que dois
arquivos PHP já foram armazenados lá. Esses arquivos de migração são dos usuários 'e 'redefinições de senha'. Laravel vem
com eles para que possamos dar uma olhada e tentar entender como ele funciona realmente.

Abra a tabela 'utilizadores'. Ele tem um nome longo: ' 2014_10_12_000000_create_users_ table.php'.

//database/migrations/2014_10_12_000000_create_users_table.php <? php

usar Illuminate \ Database \ Schema \ Blueprint; usar Illuminate \


Database \ Migrações \ Migration;

classe CreateUsersTable estende migração {

função pública para cima () {

Schema :: create ( 'usuários', function ($ table Blueprint) {


$ Table-> incrementos ( 'id'); $
Table-> string ( 'name');

© Sanjib Sinha 2017 49


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_8
Capítulo 8 ■ Migração de banco de dados

$ Table-> string ( 'email') -> única (); $ Table->


string ( 'password'); $ Table-> rememberToken (); $
Table-> timestamps (); }); }

função pública para baixo () {

Schema :: gota ( 'utilizadores'); }}

Como você vê, existem apenas duas funções: 'up' e 'baixo'. As instruções escritas no interior são bastante simples de
entender. Ela nos diz sobre a criação de colunas na tabela 'utilizadores'. Ele menciona as características das colunas: se vai
ser 'string', ou 'texto', ou ter qualquer recurso extra de exclusividade. O método 'up' significa que você gerar ou atualizar as
tabelas. O método 'para baixo' tem um significado importante. Isso significa que você pode rolar para trás suas migrações
qualquer momento, e gerá-lo novamente.

Suponha na tabela 'tarefas', de repente você pensar em mudar o nome de uma determinada coluna. Você pode reverter a
migração de idade. Você pode atualizá-lo em seu arquivo de migração PHP e, em seguida, você pode executar o comando
novamente.
Vamos começar criando mesa nossos novos 'tarefas'. Abra seu terminal e emitir este comando:

// tornando a migração
php artesão marca: create_tasks_table migração --create = "tarefas"

Depois de ter emitido este comando, ele vai executar automaticamente a migração e ele vai mostrar-lo em seu
terminal.
Depois de criar a tabela 'tarefas', ele também vai mostrar-lhe as outras migrações que foram enviados com Laravel.

// executar o comando migrar php


artesão migrar

Depois de uma migração bem-sucedida ele vai mostrar todas as migrações em um só lugar.

// mostrando as migrações
tabela de migração criado com sucesso. Migradas:
2014_10_12_000000_create_users_table migraram:
2014_10_12_100000_create_password_resets_table Migrated:
2016_08_30_024812_create_tasks_table

Agora nós realmente temos três mesas na mão. A nova tabela de tarefas 'também foi criado com sucesso.
Você pode verificá-la em seu terminal ou abrir sua ferramenta MySQL e vê-lo. Além disso, precisamos ver como
o arquivo de migração PHP foi criado em nossa " database / migrações pasta.

50
Capítulo 8 ■ Migração de banco de dados

Deve haver um arquivo chamado ' 2016_08_30_024812_create_tasks_table.php' nessa pasta. Vamos


abri-lo ver o que tem na loja para nós.

//database/migrations/2016_08_30_024812_create_tasks_table.php <? php

usar Illuminate \ Database \ Schema \ Blueprint; usar Illuminate \


Database \ Migrações \ Migration;

classe CreateTasksTable estende migração {

função pública para cima () {

Schema :: create ( 'tarefas', function ($ table Blueprint) {


$ Table-> incrementos ( 'id'); $
Table-> timestamps (); }); }

função pública para baixo () {

Schema :: gota ( 'tarefas'); }}

Você vê a diferença entre o recém-criado tabela 'tarefas' tabela 'utilizadores' padrão e. Nossa mesa
'tarefas' vem com dois métodos-como de costume, 'up' e 'down'-mas tem apenas duas colunas: 'id' e
'timestamps'.
Lembre-se, sempre que você executar uma migração, um arquivo PHP é gerado dentro ' database / migrações pasta e
parece que isso. Agora, é nossa responsabilidade para adicionar colunas para ele e novamente emitir o comando de
migração. Fizemos a mesma coisa aqui. Mudamos esta parte. Nós adicionamos título e no corpo colunas para completar
nossa mesa 'tarefas'.

//database/migrations/2016_08_30_024812_create_tasks_table.php função pública para


cima ()
{
Schema :: create ( 'tarefas', function ($ table Blueprint) {
$ Table-> incrementos ( 'id'); $
Table-> string ( 'title'); $ Table-> text (
'body'); $ Table-> timestamps (); }); }

Corremos 'migrar' comando novamente para atualizar a tabela de banco de dados. Depois que ele
automaticamente atualiza-se.

// executar o comando migrar php


artesão migrar

51
Capítulo 8 ■ Migração de banco de dados

Nesta etapa, suponha que nós esquecemos uma coluna na tabela 'tarefas' recém-criado. podemos adicioná-lo depois de
tudo as migrações são mais? Sim nos podemos fazer isso.
A grandeza de Laravel é já pensou em todas as possibilidades que podem acontecer. Desta vez, o
comando é ligeiramente diferente.

// adicionando uma nova coluna à tabela


php artesão marca: a migração add_reminder_to_tasks_table --table = "tarefas" Criado Migração:
2016_08_30_035529_add_reminder_to_tasks_table

Nós esqueceu de adicionar uma coluna 'lembrete' em nossa mesa 'tarefas'. Nós acabamos de adicionar-lo usando comando de

migração. Agora podemos ter um olhar para o nosso recém-criado banco de dados tabela 'tarefas' em nossa ferramenta phpMyAdmin (Figura  8-1

).

Figura 8-1. A tabela 'tarefas' na ferramenta phpMyAdmin

Nossa mesa 'tarefas' tem todas as colunas agora: 'id', 'title', 'body', 'timestamps', e, finalmente, 'lembrete', que nós
adicionados mais tarde.

8.1 Resumo
migração de banco de dados em Laravel é uma técnica que nos ajuda a criar, atualizar ou excluir a tabela e suas colunas.
Em um cenário de desenvolvimento, quando você trabalha em um projeto participando de diferentes destinos, você pode
facilmente modificar ou manipular seu banco de dados através de alguns comandos simples PHP.

52
CAPÍTULO 9

Eloquente

classe Modelo eloquente é usado para métodos 'de implementação registro ativo' de Laravel. É, literalmente, significa que
podemos facilmente 'criar, recuperar, UPDATE ou DELETE' qualquer registro de banco de dados usando esta classe
Eloquent Modelo.
No comando artesão Laravel PHP que gera arquivos através de 'make'. Temos visto isso antes em caso de
'controladores', 'migrações'. Agora nós podemos fazer a mesma coisa na nossa classe Model.

Lembre-se de uma coisa: se você tem uma tabela chamada 'tarefas', então você deve ter um modelo chamado
'Tarefa'. Se temos uma tabela chamada 'canções', temos de ter um modelo chamado 'Song'. No modelo, o nome começa
com a letra maiúscula e a última letra da tabela é ignorada.
Vamos criar a nossa primeira classe de modelo 'Tarefa'.

Como de costume, abrir nosso terminal e emitir este comando:

// criando modelo php tarefa artesão


marca: modelo de tarefas Modelo criado
com sucesso.

Uma vez que tenhamos emitido este comando, no 'app' pasta um arquivo PHP é gerado automaticamente.

//app/Task.php <?
php
namespace App;
usar Illuminate \ Database \ Eloquent \ Modelo; classe
Task estende Modelo {}

// código terminou

É um arquivo PHP simples com uma classe vazia e você não pode perceber o seu poder em uma só página.

Mas a realidade é diferente. classe A 'Tarefa' estende a classe 'Model', que é uma classe bastante complexa, com todo o tipo
de funcionalidade de banco de dados. Ele tem muitos métodos complexos que implementam activamente muitas coisas. Para citar
alguns, há 'salvar' , métodos
, 'encontrar' 'update' e
muito mais. Você pode salvar seu registro. Você pode atualizar seu registro. Você pode emitir uma atribuição em
massa. Há mais funcionalidade que vamos ver no futuro curso.

© Sanjib Sinha 2017 53


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_9
Capítulo 9 ■ eloquente

Vamos primeiro preencher nosso banco de dados de mesa 'tarefas' com algumas tarefas.

Para fazer isso, podemos adicionar ou atualizar registros através de um painel administrativo que tem formulários para ter
entradas ou podemos usar qualquer outro truque.
No momento nós não aprendemos nada sobre os usos de formas. Nós vamos aprender mais tarde. Assim, podemos usar 'Tinker' no

nosso terminal para adicionar alguns registros rápidas para testar nosso modelo 'Tarefa'.

O que é 'Tinker'?
É um comando artesão que vem com Laravel e nos permite trabalhar diretamente na base de código Laravel
através do terminal.
Se emitir esse comando: php artesão funileiro, ele só abre uma interface agradável no terminal para trabalhar
incessantemente.

// adicionando a tabela de banco 'tarefas' por Tinker php


artesão Tinker
Psy Shell v0.7.2 (PHP 5.5.9-1ubuntu4.14 - cli) por Justin Hileman
> > > $ Task = new App \ Task; =>
App \ Task {# 632}
> > > $ task
=> App \ Task {# 632}
> > > $-Tarefa> title = 'Minha primeira tarefa'; => "My
First tarefa"
> > > $-Tarefa> body = 'Vou acordar cedo na manhã de amanhã.'; => "Vou acordar cedo na
manhã seguinte."
> > > $-Tarefa> lembrete = 'Não se esqueça'; => "Não
se esqueça"
> > > $-Tarefa> toArray (); => [

"Título" => "My First tarefa",


"Corpo" => "Vou acordar cedo na manhã de amanhã.", "Lembrete" => "Não se
esqueça",]

> > > $-Tarefa> save (); =>


True
>>>
// acrescentando concluída

Na verdade, criamos um objeto 'tarefa' usando a classe 'Tarefa'. Agora esse objeto pode acessar
automaticamente as colunas quase como propriedades. Assista a esta parte da operação Tinker anterior.

> > > $-Tarefa> title = 'Minha primeira tarefa'; => "My
First tarefa"

Ele realmente mantém esses valores na memória. Quando você finalmente chamar o método save (), ele salva todos os
registros na tabela.
Vamos encher com um outro conjunto de registros.

// cria novo conjunto de registro php


artesão Tinker

54
Capítulo 9 ■ eloquente

Psy Shell v0.7.2 (PHP 5.5.9-1ubuntu4.14 - cli) por Justin Hileman


> > > $ Task = new App \ Task; =>
App \ Task {# 632}
> > > $-Tarefa> create ([ 'title' => 'My Second Task', 'body' => 'Gostaria de
levantar-se cedo pela manhã', 'lembrete' => 'Eu preciso comprar medicamentos'])
;
=> App \ Task {# 643
Título: "My Second Task",
corpo: "Eu gostaria de levantar-se cedo pela manhã", lembrete: "Eu
preciso comprar medicamentos", updated_at: "2016/08/30 04:45:10",
created_at: "2016/08/30 04: 45:10" , id: 2}

>>>
// criado com sucesso

Podemos atualizar o primeiro registro agora? Sim, claro que podemos.


Existem dois métodos através dos quais você pode atualizar seus registros anteriores. O primeiro método é o
velho método de escrevê-lo novamente e chamar o método save () como antes.

// agora você deseja atualizar o primeiro registro


> > > $ Task = App \ Task :: find (1); => App \
Task {# 631
id: "1",
Título: "Minha primeira tarefa",
corpo: "Eu gostaria de ir ao mercado por nove.", created_at:
"2016/08/30 04:20:53", updated_at: "2016/08/30 04:37:52",

lembrete: "Você deve ir Você precisa comprar medicamentos.",}

> > > $-Tarefa> body = 'eu vou acordar de manhã.'; => "Eu vou acordar
de manhã."
> > > $-Tarefa> save (); =>
True
> > > $-Tarefa> lembrete = 'eu devo fazer.'; => "Que
devo fazer."
> > > $-Tarefa> save (); =>
True
>>>
// registro atualizado com sucesso

Há um outro método onde você pode chamar o método update () diretamente para atualizar seu registro.

// outro método de atualização


> > > $-Tarefa> update ([ 'lembrete' => 'I deve fazer e não esquecer!']);

55
Capítulo 9 ■ eloquente

=> True
>>>
// registro atualizado com sucesso

Finalmente queremos testar uma atribuição em massa usando a classe modelo eloqüente.

> > > $ Task = new App \ Task; =>


App \ Task {# 633}
> > > $-Tarefa> create ([ 'title' => 'A minha terceira tarefa', 'body' => 'eu tenho
que começar motor do carro', 'lembrete' => 'Battery vai engasgar']);

=> App \ Task {# 646


Título: "Minha terceira tarefa",
corpo: "Eu tenho que ligar o motor do carro",
lembrete: "Battery vai engasgar", updated_at:
"2016/08/31 05:36:16", created_at: "2016/08/31
05:36:16", id : 3,}

>>>

Não deu qualquer erro. Mas teria dado o erro se não tivéssemos já mudou o eloquente 'Tarefa' classe
de modelo.
Nós já havia adicionado essa linha em que a classe vazia.

//app/Task.php <?
php
namespace App;
usar Illuminate \ Database \ Eloquent \ Modelo; classe Task
estende Modelo {

protected $ fillable = [
'Título',
'corpo', 'lembrete'];
}

Nós adicionamos uma propriedade $ preenchivel e instruímos Laravel Task classe de modelo para lembrar que três
colunas de'title ' 'corpo' e' reminder'-deve ser fillable através de atribuição em massa. Estas colunas podem ser massa
atribuído a qualquer momento.
Finalmente, podemos concluir que após a migração do banco de dados, classe de modelo eloquente realmente nos permite fazer

operações de banco de dados de forma mais flexível. Mas não é o fim; mas sim é um grande começo. classe de modelo eloquente tem

muitos mais surpreendentes presentes para desenvolvedores. Agora vamos aprendê-las através de um fluxo de trabalho completo

Model-View-Controller.

Para isso, vamos criar um novo controlador e uma vista algumas páginas que irá processar a saída do banco de
dados. Nós já criou um modelo de'Task'-assim não precisamos criar isso de novo. E usando 'mexer' artesão de comando,
nós adicionamos dois ou três registros em nossa mesa banco de dados MySQL.

56
Capítulo 9 ■ eloquente

Usaremos a classe controlador para utilizar a abstração da classe modelo eloqüente por sua vez para produzir uma bela vista
para o futuro da nossa mesa banco de dados no browser.
Será parecido com a imagem na Figura  9-1 :

Figura 9-1. Uma vista da tabela de banco de dados 'tarefas'

Este ponto de vista é um produto de um fluxo de trabalho Model-View-Controller. No próximo

capítulo vamos ver como ele funciona.

57
CAPÍTULO 10

Modelo, Vista de fluxo de


trabalho do controlador

Até agora nós aprendemos algumas coisas importantes, incluindo roteamento, controlador, vista, migrações de banco de dados, e
modelo eloqüente. Na verdade, nós aprendemos muito e feito um monte de coisas que não pode ser feito em um curto período de
tempo com essas pequenas linhas de código tal.
Nós usamos banco de dados MySQL para construir uma tabela de tarefas simples, onde agora podemos criar, recuperar, atualizar

e finalmente eliminar nossas tarefas usando funileiro em nosso terminal.

Na verdade nós fizemos um monte de coisas muito facilmente com menos código. Você construiu um CRUD fullfledged (criar,
recuperar, atualizar, excluir) aplicação sem escrever uma única linha de código SQL.

Se você não usar Laravel você teria que escrever centenas de linhas de códigos PHP e SQL. Laravel tem feito isso
de uma maneira orientada a objetos. Se você queria fazer isso sozinho, você precisa criar pelo menos 25 arquivos PHP
para obter esse gosto de divisões de camada. Além disso, você teria que usar uma ferramenta MySQL como o
phpMyAdmin. Agora, pode parecer complicado.

Qual é a característica mais marcante que temos descoberto até agora?


O que mais me impressiona é a universalidade desta aplicação. Muitas coisas foram alojados sob um telhado. Você
não tem que ir fora de sua aplicação para fazer qualquer coisa. Você pode fazer as migrações de banco de dados por criar,
atualizar ou excluir tabelas de banco de dados com a ajuda de apenas algumas linhas de código PHP. Você pode criar,
atualizar ou excluir dados no banco de dados com algumas linhas de código PHP sem se preocupar com qualquer ferramenta
MySQL. Tudo é tão simples.

Ficar dentro de sua aplicação e fazer as coisas difíceis sem sair de casa não são brincadeira. Laravel fez
isso por nós.
Agora, temos uma tabela de banco de dados completo que tenha armazenado algumas tarefas. A seguir, vamos ver como é fácil para

recuperar esses dados e presente em uma página web. Tudo o que precisamos é um controlador, uma página de vista, e um modelo.

Na verdade, nós já temos um modelo chamado 'tarefa', de modo que não precisamos criar mais. Vamos construir a classe controlador

de primeira que irá buscar os dados do banco de dados em uma página de exibição.

Vamos registrar o primeiro controlador em nossa 'routes.php'.

Route :: get ( 'tarefa', 'TaskController @ index');

© Sanjib Sinha 2017 59


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_10
Capítulo 10 ■ Modelo, Vista, workflow Controlador

Agora podemos criar um controlador usando o comando artesão. Vamos fazê-lo.

php artesão marca: TaskController

Ele cria um controlador de classe-a php file-'TaskController.php', em 'Http pasta app / /' Controllers. É uma classe
simples, sem quaisquer métodos definidos. Vamos criar um método chamado 'index', que vai buscar todos os registros da
nossa mesa 'tarefas' no banco de dados.
Para fazer isso precisamos de nossa classe modelo eloquente 'tarefa' que nós já definido no capítulo anterior.
Precisamos usar essa classe no topo da arquivo do 'TaskController.php' e apenas chamar a 'todos ()' método dele.

$ tarefas = Tarefa :: todos os ();

retornar $ tarefas;

Parece muito limpo e simples. A saída vem em 'json' assim:

[{ "Id": 1, "title": "My First tarefa", "corpo": "Eu vou acordar de manhã.", "Created_at": "2016/08/30
04:20:53", "updated_at": "2016/08/30 04:53:22", "lembrete": "devo fazer e não esquecer!"}

.....
// o resto é omitido por brevidade

Laravel sabe que a saída de um banco de dados pode ser usado para qualquer API. Assim, o formato 'json' é a
resposta para isso.
Em apenas duas linhas de código que nós recuperados todos os nossos dados de uma tabela de banco de dados. Mas, queremos

obter os dados na nossa página de vista. Precisamos criar uma página de visualização. Nós aprendemos como fazer isso. Também

aprendemos como passar dados de um controlador para uma página de vista.

Então, finalmente, a nossa classe TaskController se destaca com códigos limpos e simples que buscar todos os dados do banco de

dados usando eloquente 'Tarefa' classe de modelo.

<? Php
namespace App \ Http \ Controllers; usar App \
Task;
usar Illuminate \ Http \ Request; usar o App
\ Http \ Requests;

classe TaskController estende controlador {

índice da função pública () {


$ tarefas = Tarefa :: todos os ();

voltar view ( 'pages.task', compactas ( 'tarefas')); }}

60
Capítulo 10 ■ Modelo, Vista, workflow Controlador

Agora você deve criar um arquivo 'task.blade.php' dentro da pasta 'recursos / views / pages'. Não vou repetir a parte
HTML. Você precisa entender uma coisa importante. Em sua TaskController você pegar todos os dados do banco de dados em
uma variável chamada '$ tarefas '. A saída 'json' anterior mostra que ele é realmente um array. O que você precisa é de um loop
'foreach' para recuperá-los dentro de sua página 'task.blade.php'.

@foreach ($ tarefas como $ task)


<H3>
{{$-Tarefa> title}} </ h3>

<Div class = 'h2>


{{$-Tarefa> body}} </
div> Lembrete:

<Div class = 'h1>


{{$-Tarefa> lembrete}} </ div>
@endforeach

Para cada '$ tarefas' como '$ task' podemos obter diretamente os dados. O fluxo de trabalho for concluído.

10.1 Resumo
Ele começou a partir de construir um arquivo de ambiente em que mencionou o banco de dados padrão como MySQL e nomeou o banco
de dados como 'testdb'. Em seguida, fez as migrações de banco de dados e usando 'mexer' adicionados e atualizados algumas tarefas.
Além disso, nós nos mudamos em frente e criou uma classe de modelo eloquente 'Tarefa' desde o nosso nome da tabela de banco de
dados foi 'tarefas'. Em seguida, registrou a rota e criou uma classe TaskController e por isso passamos os dados usando o modelo 'Tarefa'
para a nossa exibição de página 'task.blade.php'.

10.1.1 O nosso próximo desafio


Para uma aplicação de banco de dados pequeno com base em texto, SQLite é bom. É rápido e baseado em arquivo. Vamos construir um

aplicativo orientado a banco de dados que irá criar, recuperar, atualizar e excluir 'comentários'. Desta vez não vai usar 'mexer' para as

operações de banco de dados. Em vez disso, vamos aprender sobre as formas e construir páginas separadas para esses trabalhos.

A página 'revisão' de um determinado usuário, John Doe, por exemplo, terá uma página inicial que irá listar os
títulos. Se alguém clica esse título, ela pode ler que a revisão em uma página separada. Ao mesmo tempo, John pode
gerenciar todo o banco de dados através de um painel onde será necessária autenticação. Através desse painel que irá
gerir o 'CRUD'. Desta vez usamos a nossa caixa de Laravel / herdade e nome esta aplicação como 'review.app', de modo
que se você digitar http://review.app você pode ver de João comentários. E você também pode inserir, atualizar e excluir
dados; será uma aplicação total de CRUD.

Vamos pisar os pés na praia! É divertido…

61
CAPÍTULO 11

SQLite é uma brisa!

Nós gostaríamos de fazer esta aplicação inteiramente baseado em banco de dados SQLite. Normalmente, para uma grande aplicação

pessoas optam por MySQL ou PgSQL, pois ele pode lidar com mais visitantes. SQLite pode não ser grande o suficiente e, basicamente,

arquivar base e da luz na natureza, mas pode facilmente resolver pequenas aplicações de médio porte com centenas de milhares de

visitantes. Assim, podemos sentir-se livre para usá-lo para a nossa aplicação CRUD. Especialmente para Laravel, SQLite é uma brisa para

usar. Em um minuto você vai entender porque eu soar tão confiante.

Para usar SQLite em Laravel você precisa mudar a configuração do banco de dados padrão. Duas linhas precisam ser alteradas.

//Code/test/blog/config/databse.php 'default' => env (


'DB_CONNECTION', 'sqlite'),

Na segunda linha, é preciso mencionar o caminho do arquivo de banco de dados SQLite.

'Conexões' //Code/test/blog/config/databse.php
=> [

'Sqlite' => [
'Motorista' => 'sqlite',
// 'banco de dados' => storage_path ( 'database.sqlite'),
'Base de dados' => env ( 'DB_DATABASE', database_path ( '/../ base de dados / banco de dados. Sqlite')),
'prefixo' => '',

],

Vamos manter o nosso arquivo SQLite no ' Código / test / blog / database /' pasta. Muitas pessoas vão para o armazenamento
pasta. Qualquer um deles vai funcionar.
Em segundo lugar, precisamos mudar o arquivo '.env'. No arquivo original que vem com Laravel, o banco de
dados padrão é mencionado como este:

//Code/test/blog/.env
DB_CONNECTION = mysql
DB_HOST = 127.0.0.1 DB_PORT
= 3306

© Sanjib Sinha 2017 63


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_11
Capítulo 11 ■ SQLite é uma brisa!

DB_DATABASE = TestDB

DB_USERNAME = raiz

DB_PASSWORD = passe

Você deve alterá-lo para isto:

//Code/test/blog/.env
DB_CONNECTION = sqlite
DB_HOST = 127.0.0.1 DB_PORT
= 3306

Portanto, a partir de agora, qualquer operação de banco de dados que você faria em seu pedido será automaticamente
registrado no arquivo de banco de dados SQLite que você criar no ' Código / test / blog / banco de dados' pasta. Normalmente, as
pessoas não vão para a criação de um novo arquivo SQLite em ' Código / test / blog / banco de dados' pasta. Eles escolher o ' Código
/ test / blog / storage / databse.sqlite' arquivo que vem com Laravel por padrão. Nesse caso, em seu caminho de banco de dados ' Código
/ test / blog / config / databse.php' você precisa mudar o caminho.

Queremos fazer uma pequena pausa do caminho habitual e criar um 'database.sqlite' at ' Código / test / blog / banco de dados' pasta.

Para fazer isso você deve ir para a pasta desejada em primeiro lugar.

cd Code / test / blog / banco de dados

Em seguida, temos que usar o comando 'toque' para criar o arquivo.

tocar database.sqlite

Agora você está pronto para fazer uma aplicação CRUD incrível usando SQLite. E para fazer isso, a primeira coisa que você tem

a fazer é preencher os formulários com entradas. Através dessas entradas, você pode inserir ou atualizar dados em seu banco de dados

SQLite baseado em arquivo.

64
CAPÍTULO 12

Sentimentos complicados de formulários adm

Para preencher os formulários, você precisa sentir as formas em primeiro lugar. Desde Laravel 5.2.45 este sentimento é um pouco

diferente. Tornou-se pouco complicado.

Você precisa instalar formulário HTML construtor de modo que você pode usar modelo de formulário lâmina Laravel; isso é realmente

importante por razões de segurança. Mas há um porém. Desde Laravel 5.2.45 o velho truque não vai funcionar. Você não pode mais usar ' compositor

exigem iluminar / html' comando para adicionar modelos de formulário construtor para seu projeto. Em vez disso, você tem que emitir esse

comando:

sudo compositor exigem laravelcollective / html

Vai demorar alguns minutos para o compositor para atualizar seu sistema. Em seguida, ele vai procurar

'fornecedores' e ' aliases'. Portanto, você deve abrir ' Código / test / blog / config / app.php' arquivo e essa linha dentro ' prestadores
de matriz.

'Fornecedores'
//Code/test/blog/config/app.php => [

/*
* Fornecedores de Serviços Framework Laravel ...
*/
...
'Collective \ Html \ HtmlServiceProvider',],

Em seguida, você deve adicionar duas linhas entre o ' aliases' matriz.

'Aliases' //Code/test/blog/config/app.php =>


[
...
'Form' => 'Collective \ Html \ FormFacade', 'Html' =>
'Collective \ Html \ HtmlFacade',

],

Agora você está totalmente carregado para usar o modelo de formulário Laravel. No próximo capítulo veremos o uso extensivo
das formas.

© Sanjib Sinha 2017 65


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_12
CAPÍTULO 13

Um aplicativo CRUD

Eu não quero elaborar esta aplicação, porque eu acredito que você é inteligente o suficiente para seguir o que terá lugar em
poucos minutos em que você vai ter um olhar para os códigos seguintes.
A aplicação que vamos fazer é muito simples. John Doe é um usuário que quer criar uma página de revisão para o seu web site.
Ele deve ter uma página de índice. A partir dessa página índice pode-se ir a secção dos comentários que ele vem mantendo detalhes.
Para fazer isso, ele tem um arquivo de migração de banco de dados em primeiro lugar.

Primeiro criamos esse arquivo (consultar o capítulo migração de banco de dados). Nosso arquivo é nomeado algo
como isto: 2016_09_03_015541_create_reviews_table.php.
O código é assim:

<? Php
usar Illuminate \ Database \ Schema \ Blueprint; usar Illuminate \
Database \ Migrações \ Migration;

classe CreateReviewsTable estende migração {

/ **
* Executar as migrações.
*
* vazio @return
*/
função pública para cima () {

Schema :: create ( 'comentários', function ($ table Blueprint) {


$ Table-> incrementos ( 'id'); $
Table-> string ( 'categoria'); $ Table->
string ( 'title'); $ Table-> texto (
'conteúdo'); $ Table-> string ( 'rating'); $
Table-> timestamps (); }); }

/ **
* Inverta as migrações.

© Sanjib Sinha 2017 67


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_13
Capítulo 13 ■ um aplicativo CRUD

*
* vazio @return
*/
função pública para baixo () {

Schema :: gota ( 'comentários'); }}

Você já escolheu arquivo de banco de dados SQLite para manter seus dados. Portanto, a próxima parte é muito
simples. Anote modelo, visualizações e controladores.
O modelo que usar neste caso, o modelo da antiga 'tarefa' não funcionará mais. Precisamos criar um novo modelo
de 'Review'. Criá-lo de acordo com o truque que você aprendeu. Emita o comando artesão. Ele será automaticamente
criado.
O ' Review.php' arquivo é criado em sua ' Código / test / blog / app' pasta.

// Código / test / blog / app / Review.php <? Php

namespace App;
usar Illuminate \ Database \ Eloquent \ Modelo;

classe revisão estende Modelo {

protected $ fillable = [
'Categoria',
'title', 'conteúdo',
'rating']; }

Em seguida, você criar uma classe de controlador. Você aprendeu antes como criar a classe do controlador: ' TaskController.php'
Arquivo.

//Code/test/blog/app/Http/Controllers/ReviewController.php <? Php

namespace App \ Http \ Controllers;

usar App \ Review;


usar o App \ Http \ Requests; usar
Illuminate \ Http \ Request;

classe TaskController estende controlador {

protegidas $ comentários; $
solicitações protegidas;

68
Capítulo 13 ■ um aplicativo CRUD

__construct função pública (comentário $ comentários, Request $ pedidos) {

$ This-> comentários = $ comentários; $ this->


solicitações = $ pedidos; }

índice da função pública () {


$ tasks = $ this-> Reviews> all ();
voltar view ( 'pages.index', compactas ( 'tarefas')); }

função pública show ($ id) {


// retorna $ tarefas por id;
$ tarefas = revisão :: findOrFail ($ id); voltar view (
'pages.show', compactas ( 'tarefas'));

}
função pública criar () {
regresso vista ( 'pages.create'); }

loja de função pública (Request $ request) {


// $ input = Request :: tudo (); //
retorna $ input; // retorna $ request->
título; $ Revisar = new Review ();

$ Comentário-> category = $ request-> categoria; $


Comentário-> title = $ request-> título; $ Comentário-> content = $
request-> conteúdo; $ Comentário-> rating = $ request->
classificação; $ Comentário-> save (); retornar "Sucesso"; }

editreview função pública () {


$ tasks = $ this-> Reviews> get (); // retorna
todos os $ tarefas;
voltar view ( 'pages.editreview', compactas ( 'tarefas'));

}
public function edit ($ id)
{
$ tasks = $ this-> Reviews> find ($ id); retornar View (
'pages.edit', compactas ( 'tarefas')); }

atualização função pública ($ id)


{
$ Revisar = $ this-> Reviews> find ($ id); $ Request = $
this-> solicitações; $ Comentário-> category = $ request->
categoria;

69
Capítulo 13 ■ um aplicativo CRUD

$ Comentário-> title = $ request-> título; $ Comentário->


content = $ request-> conteúdo; $ Comentário-> rating = $
request-> classificação; $ Comentário-> save (); retornar
"Sucesso"; }

Da classe controlador que você entender que existem alguns novos outros do que os métodos ' índice'. O
método de índice mostra a home page da página de revisão de John Doe (Figura  13-1 ).

Figura 13-1. A página de revisão de John Doe

O método de tratamento é assim:

índice da função pública () {


$ tasks = $ this-> Reviews> all ();
voltar view ( 'pages.index', compactas ( 'tarefas')); }

O código da página 'index.blade.php' na pasta de pontos de vista é uma mera repetição dos códigos anteriores que
tinham usado em nosso desenvolvimento aplicação antecipada. Estende-se um layout mestre e segue algumas regras simples.

70
Capítulo 13 ■ um aplicativo CRUD

//resources/views/pages/index.blade.php @extends (
'pages.master') @section ( 'cabeça')

@Pare
@Título da seção')
É um recém-criado Task página @stop

@section ( 'título') página Revisão


de John Doe
<P> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> @stop

@section ( 'conteúdo')
<P> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p>
@foreach ($ tarefas como $ task) <h3>

Categoria: {{$ Tarefa-> categoria}} </ h3>


<h3>

Título: <a href="/task/{{ $task-> id}} "> {{$-tarefa> title}} </a> & Sdot; & Sdot; & Sdot; &
Sdot; & Sdot;
Título: <a href="{{ action('TaskController@show', [$task-> id])}} "> {{$-tarefa> title}} </a>

& Sdot; & Sdot; & Sdot; & Sdot; & Sdot;
Título: <a href="{{ url('/task', $task-> id)}} "> {{$-tarefa> title}} </a>
</ H3>
@endforeach
@stop
@section ( 'rodapé') <p> </
p>
<P> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> <
p> </ p> <p> </ p> <p> </ p> & Sdot; & Sdot; & Sdot; & Sdot; & Sdot;

<a href="{{ url('/create') }}"> Criar Novos Comentários </a> & Sdot; & Sdot; &
Sdot; & Sdot; & Sdot; <P> </ p>

<P> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> <p> </ p> < p>
</ p> <p> </ p> <p> </ p>
Home of John Doe
@stop

O percurso necessário para esta página será bastante simples. Assumimos revisão é a nossa nova tarefa para que mantê-lo

como uma tarefa simples.

//app/Http/routes.php
Route :: get ( 'tarefa', 'TaskController @ index');

71
Capítulo 13 ■ um aplicativo CRUD

Uma vez que esta página de índice da revisão de John Doe mostrou-se, o visitante vai ser feliz para clicar nos
títulos e ler os comentários. Por que usamos a função especial 'url'. Assista a esta parte da página 'index.blade.php'.

<H3>
Título: <a href="/task/{{ $task-> id}} "> {{$-tarefa> title}} </a> & Sdot; & Sdot; & Sdot; &
Sdot; & Sdot;
Título: <a href="{{ action('TaskController@show', [$task-> id])}} "> {{$-tarefa> title}} </a>

& Sdot; & Sdot; & Sdot; & Sdot; & Sdot;
Título: <a href="{{ url('/task', $task-> id)}} "> {{$-tarefa> title}} </a>

Nós usamos três métodos apenas para mostrar-lhe os vários métodos flexíveis. No mundo real, você deve usar apenas um.
Se você perguntar a minha preferência, vou votar em qualquer um deles!
Os links clicáveis ​levará os visitantes para a página 'show.blade.php' na pasta vistas (Figura  13-2 ).

Figura 13-2. O detalhe da página de revisão

É bastante simples em nossa parte 'TaskController'. Assista a este segmento de código.

//TaskConreoller.php índice da
função pública () {
$ tasks = $ this-> Reviews> all ();
voltar view ( 'pages.index', compactas ( 'tarefas')); }

função pública show ($ id) {

72
Capítulo 13 ■ um aplicativo CRUD

$ tarefas = revisão :: findOrFail ($ id); voltar view (


'pages.show', compactas ( 'tarefas')); }

O código do 'show.blade.php' é um pouco complicado. Mas não precisa de explicação nesta fase.

//show.blade.php
@extends ( 'pages.master') @section
( 'cabeça') @stop

@Título da seção')
É um recém-criado Task página @stop

@section ( 'título') página Revisão


de John Doe @stop

@section ( 'conteúdo')
<H3>
Categoria: {{$ tarefas-> categoria}} </ h3>
<h3>

Título: {{$ tarefas-> title}}


</ H3>
<Div class = 'h2>
Revisão: {{$ tarefas-> content}} </ div>

<Div class = 'h1>


Avaliação: {{$ tarefas-> classificação}} </ div>
<p> </ p>

<a href="{{ url('/task') }}"> Back Home </a> & Sdot; & Sdot; &
Sdot; & Sdot; & Sdot; @Pare

@section ( 'rodapé') <p> </


p>
<a href="{{ url('/create') }}"> Criam Novas Comentários </a>
Home of John Doe
@stop

Agora nós pode encaminhar esta página através do arquivo 'routes.php' assim:

//routes.php
Route :: get ( 'tarefa / {id}', 'TaskController @ show');

Agora a parte importante da aplicação trata-se lentamente. Primeiro vem a parte de criação. John Doe quer criar ou
adicionar comentários às suas páginas. Ele irá adicionar categorias, título, conteúdo e classificação, um após o outro
(Figura  13-3 ).

73
Capítulo 13 ■ um aplicativo CRUD

Figura 13-3. Criar página de revisão

O processo não é muito difícil. Em um aplicativo php simples que teria tomado provavelmente algumas centenas de
linhas de código para fazer tal pedido. Mas Laravel torna a vida muito mais simples.

Na classe 'TaskController' o segmento procura a sua atenção. Nós escrevemos esta parte com dois métodos
consecutivamente.

//TaskController.php função pública


criar () {
regresso vista ( 'pages.create'); }

loja de função pública (Request $ request) {


// $ input = Request :: tudo (); //
retorna $ input;
// retorna $ request-> título; $
Revisar = new Review ();
$ Comentário-> category = $ request-> categoria; $
Comentário-> title = $ request-> título; $ Comentário-> content =
$ request-> conteúdo; $ Comentário-> rating = $ request->
classificação; $ Comentário-> save (); retornar "Sucesso"; }

Em seguida, devemos ter uma página de visualização do modelo de lâmina onde podemos utilizar os formulários. O código de

'create.blade.php' é como o seguinte.

74
Capítulo 13 ■ um aplicativo CRUD

//create.blade.php @extends (
'pages.master') @section (
'cabeça')

@Pare
@Título da seção')
Criando Comentários
@stop
@section ( 'título')
John Doe vai criar novos Comentários @stop

@section ( 'conteúdo')

<Div class = "grupo forma">


{!! Formulário :: open ([ 'url' => 'criar / tarefa']) !!} <div class =
"grupo forma">
{!! Formulário :: etiqueta ( 'categoria', 'Categoria') !!}
{!! Formulário :: texto ( 'categoria', null, [ 'class' => 'controle de formulário', 'necessário']) !!}
</ div>

<Div class = "grupo forma">


{!! Formulário :: etiqueta ( 'title', 'Título') !!}
{!! Formulário :: texto ( 'title', null, [ 'class' => 'controle de formulário', 'necessário']) !!}
</ div> <p>

</ P>
<Div class = "grupo forma">
{!! Formulário :: label ( 'conteúdo', 'Conteúdo') !!} {!! Formulário :: textarea ( 'conteúdo',
null, [ 'class' => 'controle de formulário', 'necessário']) !!} </ div> <p> </ p>

<Div class = "grupo forma">


{!! Formulário :: etiqueta ( 'rating', 'Avaliação') !!}
{!! Formulário :: texto ( 'rating', null, [ 'class' => 'controle de formulário', 'necessário']) !!}
</ div> <p>

<P> </ p>


<p> </ p>
{!! Formulário :: enviar ( "Criar Comentários") !!} {!!
Formulário :: close () !!} </ div> @stop

@section ( 'rodapé')
<a href="{{ url('/editreview') }}"> John Doe não é no humor para adicionar
novos comentários, então ele vai voltar para casa para editar seus antigos comentários! </a>

75
Capítulo 13 ■ um aplicativo CRUD

Home of John Doe


@stop

E para registrar a rota necessário, temos que escrever este pedaço de código em nossas 'rotas. arquivo php'.

//routes.php
Route :: get ( 'criar', 'TaskController @ criar'); Route :: pós ( 'criar /
tarefa', 'TaskController @ store');

Finalmente, a parte mais complicada da nossa aplicação CRUD está prestes a chegar. Parece complicado, mas
Laravel torna muito mais fácil com o conceito de ligação modelo. Desde o modelo 'Review' essencialmente desempenha o
papel principal por trás da cena, a seção de 'editar' é basicamente causado por um método especial.

A primeira coisa é a nossa parte do controlador.

//TaskController.php função pública


edit ($ id)
{
$ tasks = $ this-> Reviews> find ($ id); retornar View (
'pages.edit', compactas ( 'tarefas')); }

atualização função pública ($ id)


{
$ Revisar = $ this-> Reviews> find ($ id); $ Request = $ this->
solicitações; $ Comentário-> category = $ request-> categoria; $
Comentário-> title = $ request-> título; $ Comentário-> content =
$ request-> conteúdo; $ Comentário-> rating = $ request->
classificação; $ Comentário-> save (); retornar "Sucesso"; }

Como você pode ver, precisávamos de dois métodos. O primeiro é o método de 'editar', o que nos leva para a
página de 'edit.blade.php'. A segunda parte é, obviamente, o método 'update', que faz o trabalho por trás. Mas no final do
dia, é a ligação que o modelo é que o verdadeiro truque por trás da cena.

Primeiro vem a página 'editreview'. Se John Doe quer editar seus comentários, ele irá digitar este URL no
seu navegador: http://test.app/editreview .
Vamos ver o código em nossa página 'editreview.blade.php'.

//editreview.blade.php @extends (
'pages.master') @section (
'cabeça')

@Pare
@Título da seção')

76
Capítulo 13 ■ um aplicativo CRUD

É um recém-criado Task página @stop

@section ( 'título')
John Doe vai editar página de revisão @stop

@section ( 'conteúdo')
@foreach ($ tarefas como $ task) <h3>

Categoria: {{$ Tarefa-> categoria}} </ h3>


<h3>

Título: <a href="{{ url('/edit', $task-> id)}} "> {{$-tarefa> title}} </a>
</ H3>
@endforeach

@Pare

@section ( 'rodapé')

<a href="{{ url('/create') }}"> Criam Novas Comentários </a>

Home of John Doe


@stop

Não há nada de muito especial nesta página. Ele clica em um link e atinge a página 'editar'. O código de
'edit.blade.php' é complicado em uma linha. Atente para isso! (Veja a figura  13-4 .)

Figura 13-4. Editar página da revisão de John Doe

77
Capítulo 13 ■ um aplicativo CRUD

A página de edição onde a edição real terá lugar será um pouco diferente.

//edit.blade.php
@extends ( 'pages.master')
@section ( 'cabeça')

@Pare
@Título da seção')
É um recém-criado Task página @stop

@section ( 'título')
John Doe vai editar página de revisão @stop

@section ( 'conteúdo')

<Div class = "grupo forma">


{!! Formulário :: model ($ tarefas, [ "url" => "update / $ tarefas-> id", "método" => "PATCH"]) !!}

<Ul>
<Li>
{{Form :: etiqueta ( 'categoria', 'Categoria:')}} {{Form :: texto
( 'categoria')}} </ li> <li>

{{Form :: etiqueta ( 'title', 'Título:')}} {{Form :: texto (


'title')}} </ li> <li>

{{Form :: etiqueta ( 'conteúdo', 'Conteúdo:')}} {{Form ::


textarea ( 'conteúdo')}} </ li> <li>

{{Form :: etiqueta ( 'rating', 'Avaliação:')}} {{Form ::


texto ( 'rating')}} </ li> <li>

{{Form :: enviar ( 'Update', array ( 'class' => 'btn btn-info'))}} </ li> </ ul>

{!! Formulário :: close () !!}

</ Div>

@Pare

@section ( 'rodapé')

<a href="{{ url('/create') }}"> Criam Novas Comentários </a>

78
Capítulo 13 ■ um aplicativo CRUD

Home of John Doe


@stop

Esta parte é complicada:

{!! Formulário :: model ($ tarefas, [ "url" => "update / $ tarefas-> id", "método" => "PATCH"]) !!}

A rota subseqüente será registrado no ' routes.php' Arquivo.

//routes.php
Route :: get ( 'editreview', 'TaskController @ editreview'); Route :: get ( 'edit /
{id}', 'TaskController @ edit'); Route :: patch ( 'update / {id}', 'TaskController
@ update');

A página de edição da revisão do John Doe se parece com isso quando ele clica no título relevante para editá-los (Figura  13-5
).

Figura 13-5. A página de edição da revisão de John Doe

Nossa aplicação é completa em um simples algumas linhas de código. Você não precisa escrever uma centena de milhares
de linhas de código para realizar esta tarefa complexa.
A página de índice mostra os títulos dos comentários. Quando alguém clica nos títulos, ela pode alcançar a página de
revisão. O método 'show' no 'TaskController.php' levou-a para o detalhe dos comentários. Quando John Doe quer adicionar
comentários é muito fácil. Ele acrescenta que apenas através do preenchimento de seus formulários. Em seguida, vem a parte mais
fácil: a seção de edição. Ele clica no título e atinge a página de edição.

79
CAPÍTULO 14

Autenticação e
autorização

Laravel 5.3 faz autenticação extremamente simples, e se você estiver familiarizado com o .NET Framework,
ele irá lembrá-lo do processo de login ASP.NET e sair.
Na verdade, você não precisa ter que fazer alguma coisa. Tudo está pronto à sua porta; tudo que você precisa é
apenas ligar e ligar, e o processo de autenticação irá funcionar como uma brisa. Pessoas provenientes de Laravel 3.2 ou
4.2 fundos, encontrá-lo inacreditável, às vezes. Na verdade, você não é suposto a escrever longas linhas de código. É tão
fácil e acessível. Ele funciona apenas fora da caixa, porque tudo foi configurado de antemão e você pode ir através do
código de 'config / app.php'. Quando você instala Laravel 5, você vê dois controladores já foram criados na pasta 'app /
HTTP / Controladores / Auth /'. Estes dois controladores são 'AuthController' e 'PasswordController'. Vamos ver como
funciona o 'AuthController'. Ele é usado para novos fins de registro do usuário e login. E através de 'PasswordController'
um usuário pode redefinir sua senha. Cada um desses controladores usa traços de ter seus métodos necessários. Então
você inicialmente você não deve alterar esses controladores, a menos que você está em uma situação muito especial onde
você gostaria de personalizar o seu processo de registro e login. Vamos ver primeiro o que está dentro deste Controller
'AuthController', para que possamos entender como ele funciona fora da caixa.

<? Php

namespace App \ Http \ Controllers \ Auth;

usar Illuminate \ Support \ Fachadas \ Auth;

usar App \ User;

usar validador;

usar App \ Http \ Controllers \ Controlador;

usar Illuminate \ Foundation \ auth \ ThrottlesLogins;

usar

© Sanjib Sinha 2017 81


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_14
Capítulo 14 ■ autenticação e autorização

Iluminar \ Foundation \ Auth \ AuthenticatesAndRegistersUsers;

usar o App \ Http \ Requests;

usar Illuminate \ Http \ Request;

classe AuthController estende controlador

/*

| Registo e Acesso Controlador -------------------------------

- - - - - - - - - - - - - - - - - - - | Th é controlador manipula o registro de novo


usuários, bem como a

| autenticação de usuários existentes. Por padrão, esse controlador usa

| um traço simples de adicionar esses comportamentos. Por que você não explorá-lo?

*/

usar AuthenticatesAndRegistersUsers, ThrottlesLogins;

protected $ redirectPath = '/ dashboard';

protected $ loginPath = 'auth / login';

/ **

* Criar uma nova instância do controlador de autenticação.

* vazio @return

*/

__construct função pública ()

$ This-> middleware ( 'convidado', [ 'salvo' =>

'GetLogout']);

82
Capítulo 14 ■ autenticação e autorização

/ **

* Obter um validador para um pedido de registro de entrada.

* $ Dados de matriz @ param

* @Retorna

\ Illuminate \ Contratos \ Validação \ Validator

*/

protegido função validador ($ matriz de dados)

voltar Validador :: make ($ data [

'Name' => 'exigido | máx: 255',

'Email' => 'exigido | e-mail | máx: 255 | exclusivas: os usuários,

'Password' => 'exigido | confirmou | min: 6' ,

]);

/ **

* Criar uma nova instância de usuário após um registo válido.

* $ Dados de matriz @ param

* @return Usuário

*/

função protegida create ($ matriz de dados)

retornar usuário :: create ([

83
Capítulo 14 ■ autenticação e autorização

'Nome' => $ dados [ 'name'],

'Email' => $ dados [ 'email'],

'Password' =>

bcrypt ($ data [ 'password']),

]);

Quando você cria uma instância de autenticação, ele automaticamente chama de volta a propriedade 'middleware', e em sua rota que

você pode configurá-lo de modo que se deseja proteger qualquer página do visitante sem assinatura ou convidado que você acabou de

mencionar isso em sua rota.

__construct função pública ()

{
$ This-> middleware ( 'convidado', [ 'salvo' =>
'getLogout']);
}

O método validador (), ao mesmo tempo trabalha para que quando alguém registra que ele é orientado adequadamente
para manter a regra.

validador função protegida ($ matriz de dados) {

voltar Validador :: make ($ data [

'Name' => 'exigido | máx: 255',

'Email' => 'exigido | e-mail | máx: 255 |

exclusivas: os usuários,

'Password' => 'exigido | confirmou | min: 6',

]);

Assim, em poucas palavras o 'AuthController' é fornecido com todas as armas de fogo até em uma crise. Agora vamos
começar a construir-se um processo de autenticação agradável através do qual podemos registar e entrar. E ao mesmo tempo,
vamos ver como podemos usar 'middleware' propriedade para

84
Capítulo 14 ■ autenticação e autorização

proteger painéis de nossos usuários. Para começar, você precisa criar uma tabela 'utilizadores'. Você são fornecidos com um arquivo de

migração de usuário padrão em seu arquivo 'banco de dados / migração'. Vamos configurá-lo primeiro como este:

função pública para cima ()

Schema :: create (, função 'usuários'

($ Table Blueprint) {

$ Table-> incrementos ( 'id');

$ Table> string ( 'name');

$ Table-> string ( 'email') -> única ();

$ Table-> string ( 'password', 60);

$ Table> rememberToken ();

$ Table-> timestamps ();

});

Você vê que eu tenha configurado as colunas. Agora emitir o seguinte comando:

php migrar artesão

Tenho criado um banco de dados 'MyApp' no arquivo '.env' de antemão, para os 'utilizadores' foram adicionados ao banco de dados

agora. Agora vamos adicionar quatro páginas de exibição para a pasta 'vistas' nossa. Estas páginas são 'login.blade.php'

, 'Register.blade.php' , 'Dashboard.blade.php' , e 'home.blade.php' .

// códigos de partida 'login.blade.php'

@extends ( 'auth.master')

@Título da seção')

Página de login

@Pare

@section ( 'conteúdo')

85
Capítulo 14 ■ autenticação e autorização

<H1>

Assinar em

</ H1>

@foreach ($ errors-> all () quanto $ erro)

<Li>

{{$ Error}}

</ Li>

@endforeach

<Div class = "grupo forma">

{!! Formulário :: open ([ "URL" => "auth / login",

"Método" => "POST"]) !!}

<Div class = "grupo forma">

{!! Formulário :: etiqueta ( 'Nome:') !!} {!!

Formulário :: texto ( 'name') !!}

</ Div>

<P> </ p>

<Div class = "grupo forma">

{!! Formulário :: etiqueta ( 'Email:') !!} {!!

Formulário :: e-mail ( 'email') !!}

</ Div>

<P> </ p>

<Div class = "grupo forma">

{!! Formulário :: etiqueta ( 'Password:') !!} {!!

86
Capítulo 14 ■ autenticação e autorização

Formulário :: senha ( 'password') !!}

</ Div>

<P> </ p>

<P> </ p> <p> </ p>

{!! Formulário :: enviar ( 'Entrar') !!}

{!! Formulário :: close () !!}

</ Div>

@Pare

@section ( 'rodapé')

página Registro usuários

@Pare

// código terminou

Agora vamos criar página de cadastro.

// código de partida 'dashbaord.blade.php'

@extends ( 'auth.master')

@Título da seção')

registro Página

@Pare

@section ( 'conteúdo')

<H1>

registo

</ H1>

@foreach ($ errors-> all () quanto $ erro)

<Li>

87
Capítulo 14 ■ autenticação e autorização

{{$ Error}}

</ Li>

@endforeach

<Div class = "grupo forma">

{!! Formulário :: open ([ "URL" => "auth / register",

"Método" => "POST"]) !!}

<Div class = "grupo forma">

{!! Formulário :: etiqueta ( 'Nome:') !!} {!!

Formulário :: texto ( 'name') !!}

</ Div>

<P> </ p>

<Div class = "grupo forma">

{!! Formulário :: etiqueta ( 'Email:') !!} {!!

Formulário :: e-mail ( 'email') !!}

</ Div>

<P> </ p>

<Div class = "grupo forma">

{!! Formulário :: etiqueta ( 'Password:') !!} {!!

Formulário :: senha ( 'password') !!}

</ Div>

<P> </ p>

<Div class = "grupo forma">

{!! Formulário :: label ( 'Confirmação de Senha:') !!}

{!! Formulário :: senha ( 'password_confirmation') !!}

</ Div>

88
Capítulo 14 ■ autenticação e autorização

<P> </ p> <p> </ p>

{!! Formulário :: enviar ( 'Register') !!}

{!! Formulário :: close () !!}

</ Div>

@Pare

@section ( 'rodapé')

registro Página

@Pare

// código terminou

Para abreviar, vamos ignorar os códigos para painel e casa. Tudo é o mesmo, exceto por uma opção
de logout. Isso é assim:

<Div class = "grupo forma">

{!! Formulário :: open ([ "URL" => "auth / logout",

"Método" => "POST"]) !!}

<P> </ p> <p> </ p>

{!! Formulário :: enviar ( 'Sair') !!}

{!! Formulário :: close () !!}

Agora, finalmente, adicionar esses métodos 'routes.php'

// códigos de partida 'routes.php'

// rotas de autenticação

Route :: get ( 'auth / login',

'Auth \ AuthController @ getLogin');

Route :: pós ( 'auth / login',

'Auth \ AuthController @ postLogin');

Route :: get ( 'auth / logout',

89
Capítulo 14 ■ autenticação e autorização

'Auth \ AuthController @ getLogout');

Route :: pós ( 'auth / logout',

'Auth \ AuthController @ getLogout');

// rotas Registro

Route :: get ( 'auth / registar',

'Auth \ AuthController @ getRegister');

Route :: pós ( 'auth / registar',

'Auth \ AuthController @ postRegister');

// como proteger sua página usuários

Route :: grupo ([ 'middleware' => 'auth'], function ()

Route :: get ( 'home', function () {

regresso vista ( 'auth.home');

});

Route :: get ( 'dashboard', function () {

regresso vista ( 'auth.dashboard');

});

//funciona

// Route :: get ( 'teste', 'MyController @ test');

});

// código terminou

Agora sua página de cadastro automaticamente faz a validação do lado do servidor. Irá ver a página $ erros
'register.blade.php'> Todos (método). Ele faz o truque. Se um usuário preenche todos os campos corretamente e pressiona o botão
de registro, ele será direcionado para a página inicial automaticamente. E se ele registra em que ele vai redirecionado para o painel.
Lá ele pode assina fora. Assim, podemos concluir que a autenticação em Laravel 5 é apenas como uma moleza. Tudo que você
precisa fazer é definir a tabela de usuários, criar algumas páginas de visualização, e adicionar as rotas necessárias.

90
CAPÍTULO 15

Mais sobre Validação

Ok, não há nada de novo na validação palavra. Mesmo se você é um novato que você já sabe o que significa a validação
prazo. Muito simples. O envio de formulários em branco pode causar grande problema para o servidor e como um
desenvolvedor você também sofreria com isso. Outro grande problema é o próprio usuário. A regra de ouro é não confiar
no usuário. E isso é verdade. Você quer e-mail do usuário e algum texto está sendo fornecido em seu lugar. Como vai lidar
com esta ameaça? A resposta é a validação. E Laravel tornou muito fácil. Não só é fácil, mas com tantas opções, ele
realmente se torna algo onde as possibilidades são infinitas. Vamos considerar uma forma como antes:

{{Form :: open (array ( 'url' => '/'))}}

{{Form :: etiqueta ( 'username', 'username')}}

{{Form :: texto ( 'username')}}

{{Form :: etiqueta ( 'email', 'E Mail')}}

{{Form :: e-mail ( 'email', 'me@sanjib.me')}}

{{Campo Senha. }}

{{Form :: etiqueta ( 'password', 'Senha')}}

{{Form :: senha ( 'password')}}

{{Campo de confirmação de senha. }}

{{Form :: etiqueta ( 'passwordConfirmation', 'Password

confirmação') }}

{{Form :: senha ( 'passwordConfirmation')}}

{{Form :: open (array ( 'url' => '/'))}}

© Sanjib Sinha 2017 91


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_15
Capítulo 15 ■ Mais sobre Validação

{{Form :: oculto ( 'Hagu', 'mutu')}}

{{Forma :: aberta (matriz (

'Url'

=> 'Test / test',

'Arquivos' => true

) ) }}

{{Form :: etiqueta ( 'avatar', 'Avatar')}}

{{Form :: arquivo ( 'avatar')}}

{{Form :: enviar ( 'Enviar')}}

{{Form :: close ()}}

// fim do código

O formulário é bastante simples, com alguns truques incluídos. Mas ele atinge a página de abertura principal que pode ser
alterado para algo como 'registration.blade.php' ou qualquer coisa que você gosta. E, por padrão ele usa 'POST' pedido verbo. Agora,
como podemos validar este formulário para que ninguém envia uma solicitação em branco, causando graves problemas para a nossa
aplicação e sobrecarregar o nosso servidor? A nossa primeira prioridade deve ser os campos de formulário que não deveria ter sido
deixado em branco. Um usuário deve preencher os formulários. Nossa aplicação ficaria em que o assunto internamente. Lembre-se, a
grandeza de Laravel é que normalmente cuida este mecanismo fantasticamente. Você não precisa se preocupar com ele em tudo.
Como você pode ver, podemos definir mais regras para os nossos usuários aqui. Por exemplo, no nome de usuário, deve haver algum
valor alfanumérico. Devemos forçar o nosso usuário de seguir a regra, caso contrário, não será mantida. Como eu disse, as
possibilidades são infinitas; existem muitas mais opções. A regra é muito simples. E Laravel tomará as principais responsabilidades
para que você não precisa se preocupar com ele em tudo.

É algo como isto:

Route :: pós ( '/', function ()

$ Postdata = Entrada :: tudo ();

// vamos lidar com a forma

});

// fim do código

92
Capítulo 15 ■ Mais sobre Validação

E o próximo passo seria bastante simples:

Route :: pós ( '/', function ()

$ Postdata = Entrada :: tudo ();

$ = Verificação de matriz (

'Username' => 'alpha_num'

);

});

// fim do código

Como você vê, definimos nossos usuários seguir uma regra que diz que você deve fornecer algum valor alfanumérico. Ok, eu
espero que este seja o suficiente para fornecer uma amostra de como ele funciona. Antes de embarcar em uma nova jornada para
validação Laravel, gostaríamos de ver se poderíamos ter feito alguma validação em nosso próprio país, se não estávamos dado uma
superpotência como Laravel! Ele vai nos ajudar a esclarecer os conceitos.

Vamos testar quase mesma forma tornando-se um pouco mais curto para a brevidade. Temos três arquivos: 'form.php',
'validate.php' e 'action.php'. No primeiro arquivo, 'form.php', o formulário vai aparecer e está pronto para verificar dois campos:
nome de usuário e e-mail. Nós forçar nossos usuários para obedecer a algumas regras, como há apresentações em branco, e-mail
deve olhar como e-mail, et cetera.

// primeira página de exibição de formulário:

<H1>

O louco por Ciclo Clube

</ H1>

<H2>

Por favor Encha suas credenciais para o

excursão louco!

</ H2>

<Form method = "POST" action = "action.php"

aceitar charset = "UTF 8">

93
Capítulo 15 ■ Mais sobre Validação

<Input name = "_ token" type = "hidden"

value = "EMnZhqPbryk7oVPcrjwxuTrlHto">

<Label for = "username"> Nome </ label>

<P>

<Input name = tipo "username" = valor "text" = "Sua nome" id = "username">

<P>

<Label for = "email"> Seu e-mail </ label>

<P>

<Input name = "email" type = "text" value = "o seu e-mail"

id = "email">

<P>

<Input type = "submit" value = "Registrar">

/ Fim de código

É uma página de forma muito simples, onde você está prestes a registrar seu nome de usuário e e-mail. Vamos ver como
podemos fazer isso validá-lo na nossa classe 'validate.php'. O código de classe de validação é assim:

// inicia código

<? Php

/*

* . validar cheques classe duas coisas em nome do usuário

campo

* 1) nome de usuário não deve ser deixado em branco

* 2) Nome do utilizador deve estar entre 3 a 8 caracteres

* Em segundo lugar, verifica o campo de e-mail

* e-mail deve ter um sinal @

94
Capítulo 15 ■ Mais sobre Validação

*/

traço ValidateTrait {

função pública marcada () {

retornar "Ok, seus dados tenham sido salvos";

função pública desmarcada () {

retornar "Você não forneceu dados adequados.";

Interface ValidateInterface {

função pública make ($ value);

classe Validar implementa ValidateInterface {

usar ValidateTrait;

$ Pública _value = array ();

função pública make ($ value) {

$ This-> _value = $ value;

if (strlen ($ value) === 0 || strlen ($ value)

<3 || strlen ($ value)> 8) {

retorna falso;

elseif (is_string ($ value) && trim ($ value)

=== '') {

retorna falso;

95
Capítulo 15 ■ Mais sobre Validação

elseif (is_array ($ value)) {

retorna falso;

elseif (preg_match ( "/\@.\/ i", $ value)) {

retorna falso;

retornar TRUE;

// fim do código

Em seguida, em 'action.php' vamos validar essa dados do formulário. O código é assim:

// inicia código

<? Php

/*

* forma validando

*/

require 'validate.php';

if ($ _ POST [ '_ símbolo'] === "EMnZhqPbryk7oVPcrjwxuTrlHto") {

$ Value = [$ _ POST [ 'username'],

$ _ POST [ 'email']];

$ Validate = new Validate ();

if ($ Validar> fazer ($ value [0]) && $ validate

> fazer ($ value [1])) {

echo $ Validar> marcada ();

96

www.allitebooks.com
Capítulo 15 ■ Mais sobre Validação

outro {

echo $ validar> desmarcada ();

outro {

echo 'Você Crackers! Volte!';

// fim do código

Nós passamos um símbolo oculto e combinados com nossos dados do formulário de modo que não podem ser enviados por um

estranho. Mas poderia ser escrita de uma maneira melhor. Para abreviar temos apanhado de dados diretamente, mas acessando variedade

de super mundial diretamente não é uma boa prática. Isso pode ser feito da seguinte forma:

// inicia código

<? Php

/*

* forma validando

*/

require 'validate.php';

$ Símbolo = filter_input (INPUT_POST, '_token',

FILTER_SANITIZE_FULL_SPECIAL_CHARS);

$ User = filter_input (INPUT_POST, 'username',

FILTER_SANITIZE_FULL_SPECIAL_CHARS);

$ Email = filter_input (INPUT_POST, 'email',

FILTER_SANITIZE_EMAIL);

if ($ === token "EMnZhqPbryk7oVPcrjwxuTrlHto") {

97
Capítulo 15 ■ Mais sobre Validação

$ Value = [$ user, $ email];

$ Validate = new Validate ();

if ($ Validar> fazer ($ value [0]) && $


validate-> fazer ($ value [1])) {

echo $ validate-> marcada ();

outro {

echo $ validar> desmarcada ();

outro {

echo 'Você Crackers! Volte!';

// fim do código

Se linhas de código e fazer as coisas vêm juntas são importantes para você, você vai preferir delegar sua tarefa de Laravel.
O criador Taylor Otwell ea tarefa olhar da equipe Laravel depois de todas as possibilidades e mantido perto do princípio de que
nenhuma pedra deve ser sobre pedra. Então, tudo entra em seu lugar e você são renderizados com cada opção possível para
otimizar sua aplicação. Vamos ao nosso formulário de bicicleta velha e ver como podemos validá-lo, forçando nossos usuários a
passar por muitas tarefas que estão disponíveis no Laravel. Nós terminou aqui antes:

Route :: pós ( '/', function ()

$ Postdata = Entrada :: tudo ();

$ = Verificação de matriz (

'Username' => 'alpha_num'

);

});

// fim do código

98
Capítulo 15 ■ Mais sobre Validação

Agora sabemos o que ele diz. Mas como podemos validar esta? Existe alguma classe de validação? Sim existe! Vamos
descobrir como ele pode ser usado. Para fazer isso, precisamos configurar o nosso objeto de validação que irá verificar se a
regra é rigorosamente seguido ou não! O código é assim:

// inicia código

Route :: pós ( '/', function ()

// Obtêm todos os dados de solicitação.

$ Postdata = Entrada :: tudo ();

// Construir a restrição de validação definido.

$ = Verificação de matriz (

'Username' => 'alpha_num'

);

// Criando instância que deve ser passado.

$ ValidatingData = Validador :: make ($ postdata,

$ Cheque);

});

// fim do código

Este código não é completa, como você deve ter adivinhado, como nosso exemplo de validação deve ser passada através de
um rigoroso teste. Faremos isso em breve. Este 'postdata' pode ser qualquer coisa como você defini-lo em conformidade. Não importa.
Finalmente, o texto completo do código é assim:

// inicia código

Route :: pós ( '/', function ()

// Obtêm todos os dados de solicitação.

$ Postdata = Entrada :: tudo ();

// Construir a restrição de validação definido.

99
Capítulo 15 ■ Mais sobre Validação

$ = Verificação de matriz (

'Username' => 'alpha_num'

);

$ ValidatingData = Validador :: make ($ postdata,

$ Cheque);

if ($ validatingData> passa ()) {

// quando passa você pode inserir, atualizar seu // banco de dados. Se ele não passar você pode retornar redirecionar
para uma página de falha // também retornam 'Os dados foram salvos.'

retornar Redirect :: a ( '/ sucesso');

});

// fim do código

Agora você tem o arsenal principal, e como você disparar a partir dele é com você. Existem, obviamente, muitas outras
opções disponíveis junto com os caracteres alfanuméricos. Nesta forma, se colocarmos um nome como 'sanjib65' ele vai passar
por toda parte e os dados serão salvos. Mas em vez de valor alfabética ou numérica, colocamos alguns caracteres estranhos
como '@ !! & *', ele irá falhar. Nesse caso, podemos usar nosso código desta forma:

// partida código

Route :: pós ( '/', function ()

// Obtêm todos os dados de solicitação.

$ Postdata = Entrada :: tudo ();

// Construir a restrição de validação definido.

$ = Verificação de matriz (

'Username' => 'alpha_num'

);

$ ValidatingData = Validador :: make ($ postdata,

100
Capítulo 15 ■ Mais sobre Validação

$ Cheque);

if ($ validatingData> falhar ()) {

// Normalmente, temos que fazer alguma coisa com os dados.

retornar Redirect :: a ( '/ fracasso');

retorno 'de dados salvos.';

});

// fim do código

É bastante simples, por isso nenhuma explicação é necessária. Vamos ver como podemos adicionar muitos mais recursos para o
nosso array '$ cheque'. Suponha que queremos que o nosso nome de usuário para ter um mínimo de seis caracteres. O que podemos
fazer? Muito simples. Laravel torna a escrita como uma descrição explícita: min: 6. Este 'min: 6' pode ser alterado para 'min: 4' ou 'min: 5'
ou qualquer comprimento você precisa adotar. O código é quase o mesmo, com uma pequena mudança, como você supõe.

// partida código

Route :: pós ( '/ Registro', function ()

// Obtêm todos os dados de solicitação.

$ Postdata = Entrada :: tudo ();

// Construir a restrição de validação definido.

$ = Verificação de matriz (

'Nome de utilizador' => 'min: 6'

);

$ ValidatingData = Validador :: make ($ postdata, $ cheque);

if ($ validatingData> passa ()) {

// Normalmente, temos que fazer alguma coisa com os dados. voltar 'Os dados foram salvos.';

101
Capítulo 15 ■ Mais sobre Validação

retornar Redirect :: a ( '/ sucesso');

});

// fim do código

Em vez de 'alpha_num' você escreve 'min: 6' e que é ele. Mas espere! Há mais. Suponha que você pode adicionar ambos os
recursos para o seu nome de usuário. O que você pode fazer? maior feito de Laravel é que ele torna as coisas tão simples e elegante
que você não pode imaginar antes de usá-lo como ele está sendo processado. O código completo é assim:

// partida código

Route :: pós ( '/ Registro', function ()

// Obtêm todos os dados de solicitação.

$ Postdata = Entrada :: tudo ();

// Construir a restrição de validação definido.

$ = Verificação de matriz (

'Username' => 'alpha_num | min: 6'

);

$ ValidatingData = Validador :: make ($ postdata,

$ Cheque);

if ($ validatingData -> passa ()) {

// Normalmente, temos que fazer alguma coisa com os dados.

voltar 'Os dados foram salvos.';

retornar Redirect :: a ( '/ sucesso');

});

// fim do código

102
Capítulo 15 ■ Mais sobre Validação

Agora você já sabe que navios Laravel com uma série de facilidades de validação. E todos os truques surgiram a
partir da classe de validação. Você é livre para verificar o chore quais são todos os métodos que estão sendo usados.
Além disso, você pode ir em toda a documentação que bem explica as regras, um após o outro. Aqui eu estou tentando
dar-lhe um vislumbre do que você pode fazer com esta classe de validação. Vamos verificar este código novamente:

// partida código

$ ValidatingData = Validador :: make (

matriz ( 'nome' => 'Sanjib'),

matriz ( 'nome' => 'exigido | min: 6')

);

// fim do código

classe de validação tem um método de composição que leva o primeiro argumento como os dados que devem ser
verificados. E o segundo argumento mostra os requisitos. Você pode usar o caractere 'pipe' ou você pode usar matriz para
separar elementos como este:

// partida código

$ ValidatingData = Validador :: make (

matriz ( 'nome' => 'Sanjib'),

matriz ( 'nome' => matriz ( 'necessária', 'min: 6'))

);

// fim do código

Você também pode usar vários campos:

// partida código

$ ValidatingData = Validador :: make (

matriz (

'Name' => 'Sanjib',

'Password' => 'mypassword',

'Email' => 'me@sanjib.me'

103
Capítulo 15 ■ Mais sobre Validação

),

matriz (

'Name' => 'necessária',

'Password' => 'exigido | min: 8',

'Email' => 'exigido | e-mail | único: os usuários'

);

// fim do código

Você já viu como podemos usar 'passes' e 'não' metodologia para salvar ou rejeitar dados do formulário. Também
pode usar o método 'mensagem' para obter as mensagens de erro. É muito simples:

// partida código

$ ValidatingData = Validador :: make (

matriz ( 'nome' => 'Sanjib'),

matriz ( 'nome' => 'exigido | min: 6')

);

$ ValidatingData = Validador :: make (

matriz (

'Name' => 'Sanjib',

'Password' => 'mypassword',

'Email' => 'me@sanjib.me'

),

matriz (

'Name' => 'necessária',

'Password' => 'exigido | min: 8',

'Email' => 'exigido | e-mail | único: os usuários'

104
Capítulo 15 ■ Mais sobre Validação

);

$ Messages = $ Validator> Mensagens ();

// fim do código

Não há outra opção para recuperar mensagens de erro através do método 'falhou'.

$ FailedMessage = $ validador> falhou ();

Usando esse método, você pode pegar todas as regras falhadas que o usuário não obedecem corretamente ao preencher os
dados do formulário. Agora, obviamente, a pergunta é como podemos recuperar as mensagens de erro ou regras falharam? Quando
você chamar o método 'mensagem' em uma instância de validador, que normalmente surge com uma matriz. Obviamente, você definiu
muitos parâmetros como este:

// partida código

matriz (

'Name' => 'necessária',

'Password' => 'exigido | min: 8',

'Email' => 'exigido | e-mail | único: os usuários'

// fim do código

Agora você pode obter um por um - tal como este:

echo $ mensagens-> primeiro ( 'email');

Ou você pode obtê-lo como um todo:

// partida código
foreach ($ messages> get ( 'email') quanto $ mensagem)

echo $ mensagem. "<br>";

// fim do código

105
Capítulo 15 ■ Mais sobre Validação

Suponha que você tenha um código como este onde você já tiver definido uma abundância de regras de validação e você quer

agarrar todas as mensagens de erro de uma só vez. Como você pode fazer isso?

// partida código

$ ValidatingData = Validador :: make (

matriz ( 'nome' => 'Sanjib'),

matriz ( 'nome' => 'exigido | min: 6')

);

$ ValidatingData = Validador :: make (

matriz (

'Name' => 'Sanjib',

'Password' => 'mypassword',

'Email' => 'sanjib12sinha@gmail.com'

),

matriz (

'Name' => 'necessária',

'Password' => 'exigido | min: 8',

'Email' => 'exigido | e-mail | único: os usuários'

);

$ ErrorMessages = $ Validator> mensagens ();

foreach ($ errorMessages> all () quanto $ mensagem)

echo $ mensagem. “<br>”;

// fim do código

106
Capítulo 15 ■ Mais sobre Validação

Você deseja que as mensagens de erro de um modo formatado agradável? Laravel pensa sobre isso também. Você pode
escrever o seu código de todo assim:

// partida código

$ ValidatingData = Validador :: make (

matriz ( 'nome' => 'Sanjib'),

matriz ( 'nome' => 'exigido | min: 6')

);

$ ValidatingData = Validador :: make (

matriz (

'Name' => 'Sanjib',

'Password' => 'mypassword',

'Email' => 'me@sanjib.me'

),

matriz (

'Name' => 'necessária',

'Password' => 'exigido | min: 8',

'Email' => 'exigido | e-mail | único: os usuários'

);

$ ErrorMessages = $ validador> Mensagens ();

foreach ($ errorMessages-> all ( '<li>: mensagem </ li>')

quanto $ mensagem)

echo $ mensagem. "<br>";

// fim do código

107
Capítulo 15 ■ Mais sobre Validação

Como você pode ver, há uma abundância de opções. Taylor e sua equipe pensaram em quase todas as possibilidades
e tentou dar-lhe apoio em todas as formas possíveis. Agora vamos imaginar um exemplo mais concreto, onde temos uma
'register.blade.php' na pasta 'vistas' nossa. Temos um formulário como este:

// partida código

{{Form :: open (array ( 'url' => '/'))}}

{{Form :: etiqueta ( 'username', 'username')}}

{{Form :: texto ( 'username')}}

{{Form :: etiqueta ( 'email', 'E Mail')}}

{{Form :: e-mail ( 'email', 'me@sanjib.me')}}

{{Campo Senha. }}

{{Form :: etiqueta ( 'password', 'Senha')}}

{{Form :: senha ( 'password')}}

{{Campo de confirmação de senha. }}

{{Form :: etiqueta ( 'password_confirmation', 'Confirmação de senha')}}

{{Form :: senha ( 'password_confirmation')}}

{{Form :: open (array ( 'url' => '/'))}}

{{Form :: oculto ( 'Hagu', 'mutu')}}

{{Forma :: aberta (matriz (

'Url'

=> 'Test / test',

'Arquivos' => true

) ) }}

{{Form :: etiqueta ( 'avatar', 'Avatar')}}

{{Form :: arquivo ( 'avatar')}}

{{Form :: enviar ( 'Enviar')}}

108
Capítulo 15 ■ Mais sobre Validação

{{Form :: close ()}}

// fim do código

Agora em nossa rota podemos escrever algo como isto:

// partida código

Route :: get ( 'registrar', function ()

retornar View :: fazer ( 'user.register');

});

Route :: pós ( 'registrar', function ()

$ Regras = array (...);

$ Validador = Validador :: make (Input :: tudo (),

$ regras);

if ($ Validator> falhar ())

retornar Redirect :: a ( 'registo')


- > withErrors ($ validador);

});

// fim do código

Agora, quando as regras de validação falhar e mensagens de erro gerar, a variável $ erro é automaticamente definida
para a sessão. A maneira Laravel aborda este problema é bastante inteligente. Você não precisa ligar explicitamente as
mensagens de erro para a sua visão em rota GET. Laravel cuida disso. Como isso acontece? Laravel sempre verifica para os
erros na sessão e vincula-los à vista. Então, se ele estiver disponível, em cada variável $ error pedido está presente na
exibição. Você quer mais alguma coisa? :) Portanto, verifique para qualquer campo como este:

echo $ errors-> primeiro ( 'email');

109
Capítulo 15 ■ Mais sobre Validação

Agora é tempo para a verificação de todas as regras de validação. Há muitas e você pode obter a lista completa na
documentação. Mas deixe-me obter alguns deles para que você possa se familiarizar com eles.

// partida código

matriz (

'Field' => 'aceito'

);

matriz (

'Field' => 'alpha'

);

matriz (

'Field' => 'url'

);

matriz (

'Field' => 'tamanho: 8'

);

matriz (

'Field' => 'alpha_dash'

);

matriz (

'Field' => 'active_url'

);

matriz (

'Field' => 'after: 16/04/15'

);

110
Capítulo 15 ■ Mais sobre Validação

matriz (

'Field' => 'antes: 09/02/15'

);

matriz (

'Field' => 'exclusivas: usuários, username'

);

matriz (

'Field' => 'entre: 4,9'

);

matriz (

'Field' => 'mesmo: idade'

);

matriz (

'Field' => 'confirmar'

);

matriz ( 'campo' => 'data');

matriz ( 'campo' => 'required_without: idade, altura');

matriz ( 'campo' => 'required_with: idade, altura');

matriz ( 'campo' => 'required_if: nome de utilizador, Sanjib');

matriz ( 'campo' => 'exigido');

matriz ( 'campo' => 'numérico');

// fim do código

Eu espero que você ficaria feliz em procurar mais regras de validação da documentação Laravel. Você vai ter
mais e fazer as suas regras de validação mais interessante. Aqui brevemente terei alguma discussão.

111
Capítulo 15 ■ Mais sobre Validação

matriz (

'Field' => 'numérico'

);

Aqui você adivinhar corretamente. O campo deve ter um valor numérico. Alguns deles são bastante interessantes,
como este:

matriz (

'Field' => 'tamanho: 7'

);

Aqui 'tamanho' significa valor tudo-numérico, corda, byte de uma imagem-literalmente tudo. Como você sabe,
o tamanho às vezes realmente importa para alguém! Não é muito útil?

15.1 Regras condicionais


Às vezes, em sua matriz de entrada um campo não pode estar presente, mas você quer verificar. O que você pode fazer por
isso? Não se preocupe! Laravel pensa sobre isso e já vem com algumas soluções para o seu problema. Para um campo que não
é um grande problema, como você pode declarar a variável como este:

$ ValidatingData = Validador :: Marca ($ data, array (

'Email' => 'às vezes | exigido | e-mail',

) );

Mas em um cenário complexo é bastante diferente, como você ter presumido. Suponha que você está operando um
hotel registro e site de reservas onde há mais de um campo para você para validar. Para fazer isso, você precisa verificar as
solicitações do seu cliente para os quartos e número de apresentação de pessoas.

Você pode verificar esta declaração condicional como este:

$ ValidatingData = Validador :: Marca ($ data, array (

'Email' => 'às vezes | exigido | e-mail',

'Quartos' => 'exigido | numérico'

) );

112
Capítulo 15 ■ Mais sobre Validação

Agora provavelmente você pode querer perguntar por mais de um quarto são solicitados. Assim, no método 'às vezes'
você pode adicionar esse argumento e segurá-la no seu alvo de dados 'input' no fechamento que é passado como terceiro
argumento. Há mais casos e por um exemplo detalhado da documentação Laravel vai vir a calhar. Nesta seção validação, por
último mas não menos importante é a parte personalizada de validação. Vamos ver como podemos fazer algum progresso na
mesma.

Você pode passar uma mensagem personalizada como esta:

$ YourMessage = matriz (

'Required' => 'A: campo de atributo é necessário.',

);

$ Validador = Validador :: make ($ input, $ regras, $ yourMessage);

E você pode passar um array de mensagens não importa o quão grande você quer!

15,2 Personalizado Validação


Assim, a validação não requer muito esforço, se você sabe os truques. A coisa é, você precisa saber as classes e variáveis
​definidas por padrão. Mas, além disso, você também pode fazer algumas regras próprias de validação habituais. Laravel tem
uma tremenda capacidade de estender-se e até mesmo incentivá-lo a escrever alguns métodos impressionantes. Por isso,
nunca se sentir insegura e sempre tentar fazer justiça a esta técnica expansível. Escreva a sua própria equipe e deixar o
mundo saber sobre ele. Vamos tentar fazer alguma validação personalizada.

// validação personalizada

Validador :: estender ( 'CustomValidator',

function ($ campo, $ value, $ parâmetros)

{$ Valor de retorno == 'CustomValidator';

});

Route :: get ( '/', function ()

retornar View :: fazer ( 'forma');

});

Route :: pós ( '/ registrationPage', function ()

113
Capítulo 15 ■ Mais sobre Validação

// Obter todos os dados solicitados.

$ Dados = Entrada :: tudo ();

// Vamos construir o conjunto de validação restrição.

$ Regras = array (

'Username'

=> 'CustomValidator',

);

// Criar uma nova instância validador.

$ ValidatingData = Validador :: make ($ data, $ regras);

if ($ validatingData -> passa ()) {

// aqui normalmente fazemos alguns funcionários do banco de dados de retorno 'dos ​dados foi salvo.';

retornar Redirect :: a ( '/') -> withErrors ($ validatingData);

});

// fim do código

Como você vê, eu só estendeu a classe Validator com um método de 'estender'. Basicamente o que queríamos fazer é construir
algumas regras de validação personalizada. Assim, em Validador :: estender ()
Método precisamos passar essas regras. Temos usado um fecho para fazer isso. Se tivermos um olhar mais atento sobre o ampliar() método:

Validador :: estender ( 'CustomValidator',

function ($ campo, $ value, $ parâmetros)

retorno $ value == 'CustomValidator';

});

// fim do código

114
Capítulo 15 ■ Mais sobre Validação

Vemos que o primeiro parâmetro é um apelido, nada mais. Mas o segundo parâmetro é o fechamento,
que desempenha o papel principal.
Ele passa $ campo, $ value, $ parâmetros. O primeiro parâmetro é o campo (aqui está 'username'), eo segundo é
o valor do campo. Mas o que sobre o terceiro, que passa os parâmetros? É um conjunto de parâmetros que foram
passados ​para as regras de validação. Você pode personalizá-lo ao longo de uma classe personalizada. Sem
problemas. E, finalmente, apenas para mostrar o exemplo que eu tenha o seguinte em nosso arquivo app / routes.php:

Validador :: estender ( 'CustomValidator',

function ($ campo, $ value, $ parâmetros)

retorno $ value == 'CustomValidator';

});

Mas você pode mantê-la em qualquer arquivo no seu 'app'. E a mesma regra se aplica à classe feito sob encomenda impressionante
que você vai escrever. Suponha que em 'app' você cria uma pasta chamada 'validador' e manter a sua classe personalizada Validação
dentro dele assim:

// classe de validação personalizado

MyCustomValidation classe

CustomValidator função pública ($ field, $ value, $ parâmetros)

retorno $ value == 'CustomValidator';

// fim do código

A questão é: como você pode usá-lo dentro de seu 'routes.php'? Como você vê dentro da classe, voltamos o
apelido de 'CustomValidator'. Podemos ligá-la para o método extend () como este:

// inicial de código

// validação personalizada

115
Capítulo 15 ■ Mais sobre Validação

Validador :: estender ( 'CustomValidator',

MyCustomValidation @ CustomValidator);

Route :: get ( '/', function ()

retornar View :: fazer ( 'forma');

});

Route :: pós ( '/ registrationPage', function ()

// Obter todos os dados solicitados.

$ Dados = Entrada :: tudo ();

// Vamos construir o conjunto de validação restrição.

$ Regras = array (

'Username'

=> 'CustomValidator',

);

// Criar uma nova instância validador.

$ ValidatingData = Validador :: make ($ data, $ regras);

if ($ validatingData> passa ()) {

// aqui normalmente fazemos alguns funcionários do banco de dados de retorno 'dos ​dados foi salvo.';

retorno Redirect :: a ( '/')


> withErrors ($ validatingData);

});

// fim do código

116
Capítulo 15 ■ Mais sobre Validação

A mensagem de validação personalizada é bastante simples e não vai demorar muito esforço. Nas regras de validação
personalizadas existentes que você pode fazer isso. E não importa, ele não vai colocá-lo para um teste difícil. Deixe-me assegurar-lhe
que é uma experiência indolor e feliz codificação. Vamos ver como podemos usar uma mensagem de validação personalizada,
juntamente com nossa classe 'MyCustomValidation'.

// iniciar o código

// mensagem de validação personalizada

// validação personalizada

:: estender ( 'CustomValidator',

function ($ campo, $ value, $ params)

retorno $ value == 'CustomValidator';

});

Route :: get ( '/', function ()

retornar View :: fazer ( 'forma');

});

Route :: pós ( '/ registrationPage', function ()

// Obter todos os dados solicitados.

$ Dados = Entrada :: tudo ();

// Vamos construir o conjunto de validação restrição.

$ Regras = array (

'Username'

=> 'Min: 3',

);

117
Capítulo 15 ■ Mais sobre Validação

//

$ ErrorMessages = matriz ( 'min' => 'não menos do que três caracteres.');

// Criar uma nova instância validador.

$ ValidatingData = Validador :: make ($ data, $ regras, $ errorMessages);

if ($ validatingData> passa ()) {

// aqui normalmente fazemos alguns funcionários do banco de dados de retorno 'dos ​dados foi salvo.';

retornar Redirect :: a ( '/') -> withErrors ($ validatingData);

});

// classe de validação personalizado

// em app / validador / MyCustomValidation.php

MyCustomValidation classe

CustomValidator função pública ($ field, $ value, $ parâmetros)

retorno $ value == 'CustomValidator';

// fim do código

No código anterior, esta parte é extremamente importante.

$ ErrorMessages = matriz (

'Min' => 'não inferior a três caracteres.'

);

// Criar uma nova instância validador.

118
Capítulo 15 ■ Mais sobre Validação

$ ValidatingData = Validador :: make ($ data, $ regras, $ errorMessages);

if ($ validatingData> passa ()) {

// aqui normalmente fazemos alguns funcionários do banco de dados de retorno 'dos ​dados foi salvo.';

retornar Redirect :: a ( '/') -> withErrors ($ validatingData);

});

// fim do código

Você vê, neste $ validatingData = Validador :: make ($ data, $ regras, $ errorMessages); método, o terceiro
parâmetro é opcional para passar mensagens de erro. Ele passa uma matriz de mensagens. Se você não defini-lo ou
personalizá-lo, ele vai passar uma mensagem padrão. Se você tem mensagem de costume ele irá substituir a
mensagem padrão. É isso. Aqui exatamente a mesma coisa acontece.

15.3 Como validação de formulário Works


validação de formulário no Laravel 5 torna-se extremamente fácil. Você viu que no capítulo anterior. Você não
tem de validar os campos do formulário separadamente. Você só declará-lo em seu método Controller e os
andaimes de modelo e Visualizações está pronto para obedecer a essa regra. Vamos ver como podemos fazê-lo
no caminho mais curto! Assumimos que temos uma tabela 'canções'. Eu espero que você não se esqueceu. Eu
mostrei antes como adicionar novos registos através da lâmina de formulário. Agora vamos verificar os códigos
do 'SongsController'. Existe algum método de validação? Não, então precisamos criá-lo primeiro. Lembre-se, a
classe controlador de base de Laravel usa o traço 'ValidatesRequests', que na verdade trata cada solicitação
HTTP com um mecanismo de validação muito poderoso. Assim você não precisa se preocupar com isso.

// partida código

loja de função pública ()

$ This-> validar ($ this> pedido, [

'Título' => 'necessários | exclusivas: canções |

máx: 255' ,

'Bala' => 'necessário || máx: 255'

119
Capítulo 15 ■ Mais sobre Validação

]);

$ This -> canções -> title = $ this> pedido

> título;

$ This-> canções> lesma = $ this> pedido> lesma;

$ This-> songs-> letras = $ this> pedido>


letras;

$ This -> songs-> save ();

voltar 'Saved';

// código terminou

E, posteriormente, nós adicionamos um $ erros -> todos () método em nossa página 'createsongs.blade.php' assim:

@foreach ($ errors-> all () quanto $ erro)

<Li>

{{$ Error}}

</ Li>

@endforeach

Na sua página 'createsongs.blade.php' você pode pegar seus erros por esta lógica também:

@if (count ($ erros)> 0)

<Div class = "alertar perigo alert">

<Ul>

@foreach ($ errors-> all () como

$ Error)

<Li> {{$ error}} </ li>

@endforeach

120
Capítulo 15 ■ Mais sobre Validação

</ Ul>

</ Div>

@fim se

Portanto, há muitas maneiras que você pode fazer o seu regras de validação de trabalho. Consulte a documentação
para toda a lista de regras de validação disponíveis. Para um exemplo, vamos tentar um simples. Altere esta linha de que:

'Título' => 'necessários | exclusivas: canções | máx: 255',

para isso:

'Título' => 'necessários | exclusivas: canções | máx: 255 | min: 2',

Agora, se você preencher o campo de título com um personagem, ele imediatamente pega o erro e mostra-lo. A título deve
ser, pelo menos, dois caracteres. E há muitas opções para você, se quiser fazer uma regra de validação personalizada. Você pode
usar sua ferramenta de artesão para criar a classe validador personalizado como este:

php artesão marca: StoreSongsPostRequest pedido

Agora, a classe gerada será armazenado no 'app / HTTP / Pedidos' diretório. Então você pode adicionar algumas regras
personalizadas como antes:

myrules função pública ()

Retorna [

'Título' => 'necessários | exclusivas: canções |

: 255' ,

'Bala' => 'necessário || máx: 255 | min: 2',

'Letras' => 'necessária',

];

Agora, como você pode obter este costume Validação trabalhando? Muito simples, você pode criar a instância de
classe recém-criada na sua construção ou então usar o método store () por tipo insinuando o objeto do pedido como este:

121
Capítulo 15 ■ Mais sobre Validação

// partida código

loja de função pública (StoreSongsPostRequest $ Request)

$ Request> myrules ($ this> pedido, [

'Título' => 'necessários | exclusivas: canções |

máx: 255 | min: 2' ,

'Bala' => 'necessário || máx: 255 | min: 2',

'Letras' => 'necessária',

]);

$ This-> canções> title = $ this>


pedido> título;

$ This-> songs-> lesma = $ this> pedido> lesma;

$ This> canções> letras = $ this>


pedido> letras;

$ This> canções> save ();

voltar 'Saved';

// código terminou

No final deste capítulo, podemos concluir que a partir Laravel 5 em diante, o quadro tornou a vida de um desenvolvedor
muito mais fácil com um monte de truques fornecidos. Na verdade, a menos que haja uma situação extraordinária, você não
precisa personalizar suas regras de validação.

122
CAPÍTULO 16

Relações eloqüentes

Agora aprendemos a criar tabelas através de Migração e Tinker. Podemos também usar Eloquent ORM para fazer o mesmo. Nós
também aprendemos de atualizar ou editar nossos registros de banco de dados. Suponha que nós fizemos três tabelas: dos usuários ',
'músicas' e 'cantores'. Agora em nossa mesa 'canções' temos duas células da tabela, como você já deve ter notado. Um deles é
'user_id' eo outro é 'singer_id'. Assim, presumivelmente, um usuário insere uma canção, e ele tem um ID. No meu banco de dados que
tenha inserido três usuários: primeiro, segundo e terceiro. Então eles têm IDs de usuário, como 1,

2, e 3, respectivamente.
Eu também inserido 10 músicas, o que naturalmente têm 10 respectivas IDs de músicas. Finalmente eu tenho cinco
cantores que têm suas músicas na tabela 'canções'. Lembre-se, esses cantores pode ter uma ou duas músicas. Alguém pode não
ter qualquer música em tudo. Além disso, esses cantores também têm uma chave estrangeira 'user_id'; isto é, quando um usuário
insere o nome de um cantor em que a tabela seu ID é inserido junto com ele. Portanto, há uma relação entre esses três mesas, e
estas relações podem ser explicadas em muitas versões formatadas. Mas Eloquent torna a tarefa de gerenciar e trabalhar com
essas relações fáceis, e suporta vários tipos diferentes de relacionamentos. Eles são os seguintes:

• Um a um

• Um para muitos

• Muitos para muitos

• Tem muitos através

• Relações polimórficos

• Muitos para Muitos Relações polimórficos

Agora estamos indo para explorar essas relações, um por um usando Eloquent ORM em Laravel 4 também.
Afinal, o que é eloquente ORM? Até agora você já ouviu falar sobre MVC, que é a metodologia Model View
Controller, mas não diz nada sobre a parte do modelo.
Agora, com base nessa teoria, assumimos que, com cada tabela de banco de dados, temos um modelo associado. Nós
podemos interagir com a mesa muito facilmente.
Nós já vimos como Laravel fez a operação de banco de dados inteiro muito fácil, e eloqüente é a
nova adição a ele.
Se você quer uma definição, eloquente é a implementação do Active Record para operações de banco de dados. Agora, o
que é Active Record? Esta é uma técnica que envolve banco de dados em objetos. Suponha que você tenha uma tabela 'user'.
Você pode apresentar os dados dessa tabela como uma classe e cada linha como um objeto.

© Sanjib Sinha 2017 123


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_16
Capítulo 16 ■ relações eloqüentes

Agora cada tabela de banco de dados tem um modelo correspondente que vai fazer cada operação que CRUD faz.
Você sabe CRUD: criar, recuperar, atualizar e excluir. Agora você pode fazê-los muito facilmente através Eloquent ORM. O
que é ORM? Objecto mapeamento relação. Ou seja, você pode ter um conjunto definido de relações entre as tabelas
correspondentes.
Como vimos em nosso processo de construção de consulta de banco de dados, uma tabela pode ter muitas relações entre
outras tabelas. Eloquent ORM tem uma relação embutido. Ele faz a nossa vida muito mais fácil.

De Laravel 4.1 Eloquent se torna mais poderosa, pois tem anexado um recurso muchrequested: polimórfica muitos
para muitos relação. Agora você não precisa escrever um monte de código para estabelecer um Muitos polimórfica para
muitos entre tabelas. Eloquente faz isso com bastante facilidade. Temos tabela 'users' e nós temos uma classe 'User' em
nosso modelo como este:

// partida código

//models/User.php

<? Php

usar Illuminate \ Auth \ UserTrait;

usar Illuminate \ Auth \ UserInterface;

usar Illuminate \ Auth \ lembretes \ RemindableTrait;

usar Illuminate \ Auth \ lembretes \ RemindableInterface;

classe de usuário estende implementos Eloquent

UserInterface, RemindableInterface {

usar UserTrait, RemindableTrait;

/ **

* A tabela de banco de dados usado pelo modelo.

* corda @var

*/

protegidas $ tabela = 'usuários';

/ **

* Os atributos excluídos de forma JSON do modelo.

124
Capítulo 16 ■ relações eloqüentes

* matriz @var

*/

protected $ escondido = array ( 'password', 'remember_token');

// fim do código

Agora em nossa routes.php temos um código como este:

// partida código

//routes.php

Route :: get ( '/', function ()

$ User = Usuário :: tudo ();

var_dump ($ user);

});

// fim do código

Uma vez que temos quatro usuários até agora, a saída anterior mostra um por um durante toda a chave => pares
de valor. Começa a partir de 0 e termina em 3.
O que ele diz? Ele diz que esta representação é de um objeto de modelo de classe de usuário. Na classe de usuário que
você definiu duas propriedades já:

// trecho de código de user.php

/ **

* A tabela de banco de dados usado pelo modelo

* corda @var

*/

125
Capítulo 16 ■ relações eloqüentes

protegidas $ tabela = 'usuários';

/ **

* Os atributos excluídos do formulário JSON do modelo

* matriz @var

*/

protected $ escondido = array ( 'password', 'remember_token');

// código é incompleta

Agora compará-los com estas duas linhas: 'table' protegidos => string 'usuários' (comprimento = 5) protegido 'escondido'
=> array (size = 2) ...
Espero que essa comparação vai inspirá-lo a definir mais propriedades na classe de usuário! E o que pode
ser definida está sendo dito na saída anterior.
Há um lote de imóveis como 'conexão', 'relações', 'guardada', 'fillable', et cetera. Agora espero que você entenda que essas
propriedades podem ser definidas em sua classe de usuário: não só na classe de usuário em sua pasta Models, mas em qualquer
classe que você vai escrever por si mesmo. Suponha que temos uma outra tabela chamada 'contatos'. Nós podemos criar uma
classe de Contato em nossa pasta Models. Vamos criá-lo com algumas propriedades.

// partida código

//models/Contact.php

<? Php

classe Contactar estende Eloquent {

/ **

* A tabela de banco de dados usado pelo modelo

* corda @var

*/

protegidas $ tabela = 'contatos';

126
Capítulo 16 ■ relações eloqüentes

// fim do código

Agora vamos para a nossa routes.php e mudar o código para isso:

// partida código

//routes.php

Route :: get ( '/', function ()

$ Usercontacts = Contato :: tudo ();

var_dump ($ usercontacts);

});

// fim do código

Temos a mesma saída que antes da tabela 'users', como, com apenas uma exceção. A única exceção é
nesta linha:

protegido 'table' => string 'contatos' (comprimento = 8)

Basicamente, exceto este, cada propriedade é predefinido, mas a qualquer momento você pode substituí-los assim. Em
sua classe de usuário, você escrever algo como isto:

// partida código

//User.php

classe de usuário estende Eloquent {

protected $ protegida = array ( 'password');

// fim do user.php

Isso significa que o 'password' da tabela 'utilizadores' não é mais massa atribuíveis. Você pode até mesmo bloquear todos os
atributos de atribuição em massa como este:

protegido $ guardado = matriz ( '*');

Assim, as possibilidades são infinitas. E vamos mais tarde voltar a essas propriedades e discutir de forma
detalhada. Antes que eu ficaria em algum edifício de consulta normalmente definidos ao longo nossos modelos.
Suponha que nós queremos encontrar o país do primeiro

127
Capítulo 16 ■ relações eloqüentes

Contatos. Laravel Eloquent ORM navios com metodologia razoavelmente moderada que podem ajudá-lo a encontrá-lo com bastante
facilidade.
Considere este código:

Route :: get ( '/', function ()

$ Usercontacts = Contato :: find (1);

var_dump ($ usercontacts> país);

});

podemos ver todos os contatos de uma forma JSON bem formatada? Vamos ver:

Route :: get ( '/', function ()

$ Usercontacts = Contato :: tudo ();

foreach ($ usercontacts como $ key => $ value) {

echo $ chave. "=". $ Value. "<br>";

});

A saída JSON é assim:

0 = { "id": "1", "user_id": "1", "endereço": "Endereço de Admin", "country": "Marte", "ph one": "12445"}

1 = { "id": "2", "user_id": "2", "endereço": "Endereço de Sanjib", "country": "Jupiter"


, "Telefone": "456"}

2 = { "id": "3", "user_id": "3", "endereço": "Endereço de Debangshu", "country": "Moon"


, "Telefone": "567"}

3 = { "id": "4", "user_id": "8", "endereço": "Endereço de Mana", "country": "Sun", "ne pho": "234"}

Parece que Laravel tenha pensado nisso mais cedo e está tentando usar a vantagem de JSON ou JavaScript Object
Notation. Essencialmente, é uma forma de leitura humana de armazenar o valor de uma matriz ou de um objecto como cordas.
Basta pegar o primeiro valor a partir da primeira linha da nossa mesa Contatos e ver o que ele diz.

128
Capítulo 16 ■ relações eloqüentes

0 = { "id": "1", "user_id": "1", "endereço": "Endereço de Admin",


"country": "Marte", "telefone": "12445"}

Ele diz: nosso objeto $ contato produz uma série que tem todos os valores da tabela 'contatos'. A primeira chave,
que é 0, obviamente, representa a primeira linha da tabela 'contatos'.
Agora você pode perguntar, por que Laravel escolher JSON? Há muitas razões, mas uma delas é definitivamente
velocidade. O uso comum do JSON é quando uma parte de front-end de sua aplicação quer dados de back-end sem
carregamento da página.
O mesmo objetivo pode ser alcançado por JavaScript com um pedido de AJAX. Velocidade realmente importa quando
você lida com um bem grande aplicação, não é?
Não vai fora de contexto se discutir um pouco sobre JSON aqui. Eu espero que você me permitiria dizer-lhe
algo mais. Para um iniciante, é bom saber que PHP começa a serialização de matrizes e objetos de JSON de sua
versão 5.2.0. Você pode ter ouvido sobre serialize () e unserialize () métodos em PHP. Não é nada, mas a
conversão de um objeto a corda e reverter para uma nova instância para voltar o seu valor.

Eu disse JSON é uma forma legível, mas praticamente não é realmente muito legível como JSON armazena dados sem
espaço em branco entre eles. Por quê? Como eu disse, a velocidade é importante! Agora, de volta ao nosso velho discussão. A saída
significa que cada contacto fileira objecto foi incluído em uma matriz. Assim, podemos quebrá-las para saber mais nisso como este:

Route :: get ( '/', function ()

$ Contact = Contato :: tudo ();

foreach ($ contato como valor R $) {

var_dump ($ value);

});

Agora a saída é extremamente importante, e mostra explicitamente como Contato classe se comporta e cria seu
objeto. Aqui vemos quatro objetos de contato, com cada um tendo suas propriedades bem definidas. Nós estendemos
nossa classe Contato de Eloqüente e, assim que herdamos essas propriedades.

Estamos interessados ​sobre a primeira parte da saída anterior:

objeto (Contacto) [141]

protegido 'table' => string 'contatos' (comprimento = 8)

protegido 'conexão' => nulo

protegido 'primaryKey' => string 'id' (comprimento = 2)

129
Capítulo 16 ■ relações eloqüentes

protegido 'PerPage' => int 15

público 'incrementar' => boolean true

'timestamps' públicas => boolean true

protegido 'atributos' =>

matriz (tamanho = 5)

'Id' => string '1' (comprimento = 1)

'User_id' => string '1' (comprimento = 1)

'Endereço' => string 'Endereço do Admin' (comprimento = 16)

'País' => string 'Mars' (comprimento = 4)

'Telefone' => string '12445' (comprimento = 5)

protegido 'original' =>

matriz (tamanho = 5)

'Id' => string '1' (comprimento = 1)

'User_id' => string '1' (comprimento = 1)

'Endereço' => string 'Endereço do Admin' (comprimento = 16)

'País' => string 'Mars' (comprimento = 4)

'Telefone' => string '12445' (comprimento = 5)

protegidas 'relações' =>

matriz (tamanho = 0)

esvaziar

......

Você vê esta saída é incompleta, mas serve o propósito. Há lotes de imóveis como 'mesa', 'ligação',
'atributos', 'original', et cetera. Cada propriedade é uma matriz. E, finalmente, Laravel produz em JSON. Agora, para
recuperar todos os dados que você acabou de pegar a chave e o valor sairá como isto:

// partida código

130
Capítulo 16 ■ relações eloqüentes

Route :: get ( '/', function ()

$ Contact = Contato :: tudo ();

foreach ($ contato como valor R $) {

echo "Contact ID =". $ Valor-> id. "<br>";

echo "User ID =". $ Valor-> user_id.

"<br>";

echo "Endereço =". $ Valor-> endereço.

"<br>";

echo "País =". $ Valor-> país.

"<br>";

echo "Telefone =". $ Valor-> telefone.

"<br>";

// var_dump ($ value). "<br>";

});

// fim do código

E a saída é bastante esperado. Ele mostra todos os detalhes de contatos com ID de usuário.

//a saída

Contact ID = 1

User ID = 1

Address = Endereço do Administrador

País = Marte

Telefone = 12445

131
Capítulo 16 ■ relações eloqüentes

Contact ID = 2

User ID = 2

Address = Endereço de Sanjib

País = Júpiter

Telefone = 456

Contact ID = 3

User ID = 3

Address = Endereço de Debangshu

País = Lua

Telefone = 567

Contact ID = 4

User ID = 8

Address = Endereço de Mana

País = Sun

Telefone = 234

// extremidade de saída

O cerne do modelo Eloquent é este. Agora vamos fazer alguma consulta com o nosso modelo eloquente. Primeiro vamos verificar

com base na idade do usuário. Temos classe de usuário definido anteriormente. Em primeiro lugar, queremos verificar dois usuários que

tenham idades correspondentes de mais de 18.

// partida código

Route :: get ( '/', function ()

$ Users = Usuário :: onde ( 'idade', '>', 18)


> ter (2)

> pegue();

foreach ($ usuários como $ user)

132
Capítulo 16 ■ relações eloqüentes

var_dump ($ user> nome de usuário);

});

// fim do código

Lembre-se, temos apenas três usuários em nossa mesa usuários que têm idade acima de 18. Nós temos os dois primeiros.

//saída

cadeia 'administração' (comprimento = 5)

cadeia 'Sanjib' (comprimento = 6)

// extremidade de saída

Ela produz com base na identificação do usuário. Ele vai em 1, 2, 3, e assim por diante. Se há milhões de usuários e você não
precisa processar todos eles para evitar comer até sua memória, um bom método é pedaço (). Com apenas quatro usuários é difícil
mostrar-lhe como ele funciona, mas ainda podemos ter uma chance e se divertir um pouco, na verdade.

// partida código

Usuários :: pedaço (100, function ($ utilizadores)

foreach ($ usuários como $ user)

// agarrar a $ user aqui

});

// fim do código

Inserir, atualizar ou excluir com a ajuda de Eloquent é bastante fácil como você já assumido. Você não precisa
escrever um monte de código; em vez disso você só escrever duas ou três linhas de código para fazer o seu trabalho de
uma forma segura.

133
Capítulo 16 ■ relações eloqüentes

// partida código

Route :: get ( '/', function ()

$ User = new User ();

$ User-> username = 'NewUser';

$ User-> password = password_hash ( 'pass', PASSWORD_BCRYPT);

$ User -> símbolo = 'kljhnmbgfvcdsazxwetpouytresdfhjkmnbbvcdsxza';

$ User> age = 27;

$ User-> created_at = time ();

$ User> updated_at = time ();

$ User> save ();

voltar 'Saved NewUser';

});

// final de codificação

Vamos ver como o novo usuário 'NewUser' foi criado em nossa mesa 'usuários'. Para ver seus detalhes é muito fácil
agora. Sabemos de sua idade, ou seja, 27. Então, anote este código:

// partida código

Route :: get ( '/', function ()

$ Users = Usuário :: onde ( 'idade', '=', 27)> get ();

foreach ($ usuários como $ user) {

var_dump ($ user);

});

// final de codificação

134
Capítulo 16 ■ relações eloqüentes

Agora temos vindo a saber como este novo objeto de usuário vai olhar quando usamos var_ método de despejo (). Há
método vários create () de Modelos eloqüente. Você pode criar muitos usuários de uma só vez. Além disso, você pode
recuperar e atualizar qualquer usuário com uma quantidade mínima de codificação assim:

// partida código

Route :: get ( '/', function ()

$ User = Usuário :: find (2);

$ User> username = 'Babu';

$ User -> save ();


voltar 'Saved!';

});

// final de codificação

Sabemos que segundo usuário era 'Sanjib' mas agora com sucesso, foi gravada em 'Babu'. Exclusão é muito mais
fácil do que antes. Se deseja excluir o usuário 'NewUser' precisamos escrever sql como esta:

"DELETE FROM` sanjib`.`users` onde `users`.`id` = 10"?

Não é bastante longa? Porque antes desta linha que você precisa ter para se conectar manualmente para o seu banco de dados, et

cetera. Em Modelos eloqüentes é muito mais fácil, como você tem todas as coisas configurar de antemão. O código é simples:

// partida código

$ User = Usuário :: find (10);

$ User -> delete ();

// final de codificação

Antes de concluir a nossa discussão eloqüente, eu gostaria de dizer algo sobre essas propriedades
novamente. Sempre que você está indo para criar uma nova classe em seus modelos eloqüente, você tem algumas
propriedades já definidas e definir. Laravel tem feito isso por padrão. Vimos essas propriedades antes. Um deles é
Timestamps. Por padrão Eloquent mantém as colunas created_at e updated_at de seu banco de dados
automaticamente e você não precisa se preocupar com isso.

Suponha que você execute um código como este para chegar a todos os usuários que pertencem à idade inferior a 28 grupo.

135
Capítulo 16 ■ relações eloqüentes

// partida código

Route :: get ( '/', function ()

$ Users = Usuário :: onde ( 'idade', '<', 28)


> tomar (2) -> get ();

foreach ($ usuários como $ user)

var_dump ($ user);

});

// fim do código

Sabemos a saída e para que não repita mais isso. Mas olhe para essas propriedades, como 'marcas de tempo',
'fillable', ou 'vigiado'. Enquanto Eloquent mantém-los, não é nenhum problema, mas se queremos mudá-los de acordo com
os nossos critérios: então o que acontece?
Vejamos a ele. Suponha que nós queremos fazer 'falso' timestamps e também trazer algumas mudanças em propriedades
'preenchíveis' e 'guardados'. O código é assim na nossa classe de usuários antes de alterar as propriedades:

// partida código

//models/User.php

<? Php

usar Illuminate \ Auth \ UserTrait;

usar Illuminate \ Auth \ UserInterface;

usar Illuminate \ Auth \ lembretes \ RemindableTrait;

usar Illuminate \ Auth \ lembretes \ RemindableInterface;

classe de usuário estende implementos Eloquent

UserInterface, RemindableInterface {

usar UserTrait, RemindableTrait;

136
Capítulo 16 ■ relações eloqüentes

/ **

* A tabela de banco de dados usado pelo modelo.

* corda @var

*/

protegidas $ tabela = 'usuários';

/ **

* Os atributos excluídos do modelo de

formulário de JSON.

* matriz @var

*/

protected $ escondido = array ( 'password', 'Remember_token');

$ timestamps públicas = false;

protegido $ fillable = matriz ( 'nome de utilizador', 'de token');

protected $ protegida = array ( 'id', 'password');

// fim do código

Como você vê, eu tenho comentado essas propriedades. Agora nós estamos indo para alterar a classe de usuário, e o
código final é assim:

// partida código

//models/User.php

<? Php

usar Illuminate \ Auth \ UserTrait;

usar Illuminate \ Auth \ UserInterface;

137
Capítulo 16 ■ relações eloqüentes

usar Illuminate \ Auth \ lembretes \ RemindableTrait;

usar Illuminate \ Auth \ lembretes \ RemindableInterface;

classe de usuário estende implementos Eloquent

UserInterface, RemindableInterface {

usar UserTrait, RemindableTrait;

/ **

* A tabela de banco de dados usado pelo modelo.

* corda @var

*/

protegidas $ tabela = 'usuários';

/ **

* Os atributos excluídos do modelo de

formulário de JSON.

* matriz @var

*/

protected $ escondido = array ( 'password', 'remember_token');

$ timestamps públicas = false;

protegido $ fillable = matriz ( 'nome de utilizador', 'de token');

protected $ protegida = array ( 'id', 'password');

// fim do código

138
Capítulo 16 ■ relações eloqüentes

tabelas de banco de dados têm relações entre eles. É obviamente verdade que um usuário poderia colocar sua
ordem sabendo que a ordem será adicionado à sua conta. Três mesas estão associados instantaneamente. Eloqüente
torna esta parte gerir muito fácil. No nosso banco de dados 'Sanjib' anterior temos duas tabelas relacionadas: 'Usuários' e
'Contatos'. Em nossa classe User vamos escrever um método que corresponde à Contactar Modelo. Ou seja, um usuário
tem um contato. Laravel tem o método já: hasOne (), o qual passa um parâmetro que tem relação com esse modelo.

// partida código

//models/User.php

<? Php

usar Illuminate \ Auth \ UserTrait;

usar Illuminate \ Auth \ UserInterface;

usar Illuminate \ Auth \ lembretes \ RemindableTrait;

usar Illuminate \ Auth \ lembretes \ RemindableInterface;

classe de usuário estende implementos Eloquent

UserInterface, RemindableInterface {

usar UserTrait, RemindableTrait;

/ **

* A tabela de banco de dados usado pelo modelo

* corda @var

*/

protegidas $ tabela = 'usuários';

/ **

* Os atributos excluídos do modelo de

formulário de JSON

139
Capítulo 16 ■ relações eloqüentes

* matriz @var

*/

protected $ escondido = array ( 'password', 'remember_token');

$ timestamps públicas = false;

protegido $ fillable = matriz ( 'nome de utilizador', 'de token');

protected $ protegida = array ( 'id', 'password');

contacto função pública ()

return $ this-> hasOne ( 'Contato');

// fim do código

Em nossa tabela 'utilizadores', nome de usuário 'mana' tem ID de usuário 8. Em 'contatos' que ela tem ID primário 4, mas tem um

user_id correspondente 8. Então, a nossa intenção é chegar a tabela 'contatos' através de modelo do usuário. Por essa razão, nós

adicionamos esta metodologia para o Modelo de Usuário:

contacto função pública ()

return $ this-> hasOne ( 'Contato');

Agora, quando nós escrevemos na nossa routes.php, código como este:

// partida código

//routes.php

Route :: get ( '/', function ()

$ Contact = Usuário :: find (8) -> contato;

140
Capítulo 16 ■ relações eloqüentes

var_dump ($ contato);

});

// fim do código

Nós realmente chegar a tabela 'contatos' através do nosso Modelo de usuário e encontrar cuja user_id é 8. A
saída sai diretamente da tabela de 'Contatos' e produz os contactos detalhados de usuário 'mana'.

Não há nada de novo nisso. Basicamente, o SQL realizada neste código é correspondente a este:

// instrução SQL

Selecione * de usuários onde id = 8

Selecione * de telefones onde user_id = 8

// fim da instrução SQL

Esta relação é chamada de um para um. Você pode definir o inverso da relação no contato modelo usando o
método belongsTo () passando o nome da tabela como seu primeiro parâmetro. Nesse caso, em nossa Contacto Classe
vamos escrever código como este:

// partida código

//models/Contact.php

<? Php

classe Contactar estende Eloquent {

/ **

* A tabela de banco de dados usado pelo modelo.

* corda @var

*/

protegidas $ tabela = 'contatos';

user função pública ()

141
Capítulo 16 ■ relações eloqüentes

retornar $ this> belongsTo ( 'User');

// fim do código

Agora, se nós escrevemos este código em nossa routes.php:

// partida código

//routes.php

Route :: get ( '/', function ()

$ Contact = Contato :: find (4) -> user;

var_dump ($ contato);

});

// fim do código

Isso significa na tabela 'contatos' nosso buscamos todo o ID e ver se ele tem um user_id correspondente com isso.
Atualmente, na tabela 'contatos' nossa, temos correspondente user_id 10 com os contatos ID 4. Esse relacionamento
significa que o ID contatos 4 tem todos os detalhes do usuário na tabela 'users' e olha em cima em seu user_id
correspondente para ver o que o número existe. Neste caso, os contatos ID 4 tem um user_id correspondente 10. Por isso, é
convencido de que na tabela 'utilizadores' tem um ID 10. Na tabela de usuários do ID 10 pertence ao nosso recém-criado
User 'NewUser'. Algumas páginas de volta, criamos 'NewUser' através do método de inserção usando eloquente.

Em última análise, traz à tona a saída do 'NewUser'. Agora você precisa entender que pouca diferença
complicada entre estes dois métodos:

//User.php

contacto função pública ()

return $ this-> hasOne ( 'Contato');

//Contact.php

142
Capítulo 16 ■ relações eloqüentes

user função pública ()

return $ this-> belongsTo ( 'User');

Este hasOne () em pesquisas de classe de usuário para correspondente user_id na tabela 'contatos' e belongsTo () in
contact.php apenas diz respeito a sua ID primário para o user_id correspondente na tabela. Ambas as formas, user_id
desempenha o papel vital e define que a One to One relacionamento, mas, de uma maneira diferente.

Da mesma maneira muito facilmente podemos estabelecer relação um para muitos entre tabelas. Suponha que um usuário tem muitos

posts em nossa mesa 'mensagens'. Como podemos obter todos os seus artigos de uma só vez?

Há um método, hasMany (), que passa semelhante parâmetros que podem fazer essa consulta SQL com muita
facilidade. No nosso modelo User primeiro devemos definir esse método desta forma:

// partida código

//models/User.php

<? Php

usar Illuminate \ Auth \ UserTrait;

usar Illuminate \ Auth \ UserInterface;

usar Illuminate \ Auth \ lembretes \ RemindableTrait;

usar Illuminate \ Auth \ lembretes \ RemindableInterface;

classe de usuário estende implementos Eloquent

UserInterface, RemindableInterface {

usar UserTrait, RemindableTrait;

/ **

* A tabela de banco de dados usado pelo modelo

* corda @var

*/

143
Capítulo 16 ■ relações eloqüentes

protegidas $ tabela = 'usuários';

/ **

* Os atributos excluídos do modelo de

formulário de JSON

* matriz @var

*/

protected $ escondido = array ( 'password', 'remember_token');

$ timestamps públicas = false;

protegido $ fillable = matriz ( 'nome de utilizador', 'de token');

protected $ protegida = array ( 'id', 'password');

contacto função pública ()

return $ this-> hasOne ( 'Contato');

pós função pública ()

return $ this-> hasMany ( 'Post');

// fim do código

E depois disso, vamos pegar cada artigo escrito por qualquer user_id mencionado na tabela 'posts' em nosso arquivo
routes.php. E o código é a seguinte:

// partida código

//routes.php

144
Capítulo 16 ■ relações eloqüentes

Route :: get ( '/', function ()

$ Posts = Usuário :: find (10)> pós;

foreach ($ posts como $ value) {

echo "Este post feito por ID de


usuário: {$ value> user_id} <br>";

echo "Intro:". $ Valor-> introdução. "<br>";

echo "Artigo:". $ valor-> artigo

"<br>";

echo "Tags:". tag $ valor->

"<br>";

});

// fim do código

Finalmente, temos todas as mensagens enviadas pela 'NewUser' cuja usuário ID é 10. Basicamente, os artigos
mostrados aqui são para fins de teste. Agora você pode, espero, escrever seu próprio CMS baseado em Laravel. Finalmente
vamos verificar muitos para muitos relação. Existem algumas situações em que os usuários podem ter papéis diferentes ao
mesmo tempo. Vamos primeiro adicionar uma tabela para nosso banco de dados: papéis. Em seguida, atribua alguma coluna
como id, nome, created_at e updated_at. Agora temos quatro funções: Administrador, Moderador, Colaborador, e membros.
Tivemos cinco usuários. Alguns deles têm papéis comuns: por exemplo, o usuário 'admin' é Administrador, Moderador, e
colaborador. O usuário 'NewUser' também é assim. O resto deles têm papéis diferentes: por exemplo, o usuário 'Babu' é
moderador e, assim como contribuinte, et cetera. Esta é uma relação muito complexa, mas navios Laravel com uma solução
muito simples. Ele tem um método chamado belongsToMany () método que definiria essa relação, mas precisamos de uma
tabela intermediário para se juntar duas tabelas: usuários e funções. Que a tabela intermediário é chamado de 'role_user'. O
nome é derivado da ordem alfabética dos nomes modelo relacionado. A tabela 'role_user' deve ter duas colunas: ROLE_ID e
user_id. Dessa forma, você pode construir muitos para muitos relações com bastante facilidade.

/ * Temos mesa role_user preenchido com diferentes responsabilidades. Você pode executar esse SQL de
uma só vez para testar a sua aplicação. Basta criar a tabela 'role_user' em seu banco de dados 'Sanjib' e
executar este SQL: * /

//role_user.SQL

145
Capítulo 16 ■ relações eloqüentes

- - phpMyAdmin Dump SQL

- - versão 4.0.10deb1

- - http://www.phpmyadmin.net

--

- - Host: localhost

- - Tempo de geração: 30 de março de 2015 em 08:43

- - versão do servidor: 5.5.41-0ubuntu0.14.04.1

- - PHP Versão: 5.5.21-1 + deb.sury.org ~ precisa + 2

SET sql_mode = "NO_AUTO_VALUE_ON_ZERO";

SET time_zone = "+00: 00";

/ *! 40101 SET

@OLD_CHARACTER_SET_CLIENT = @@ character_set_client * /;

/ *! 40101 SET

@OLD_CHARACTER_SET_RESULTS = @@ CHARACTER_SET_RESULTS * /;

/ *! 40101 SET

@OLD_COLLATION_CONNECTION = @@ collation * /;

! / * 40101 SET NAMES utf8 * /;

--

- - Base de dados: `sanjib`

--

-- --------------------------------------------------------

--

- - estrutura de tabela para a tabela `role_user`

--

146
Capítulo 16 ■ relações eloqüentes

CREATE TABLE SE NÃO EXISTE `role_user` (

`Id` int (11) não NULL AUTO_INCREMENT,

`Int user_id` (11) não nulo,

`Int role_id` (11) não nulo,

`Created_at` PADRÃO timestamp NOT NULL CURRENT_TIMESTAMP ON

ATUALIZAÇÃO CURRENT_TIMESTAMP,

`Timestamp não padrão NULL updated_at` '0000-00-00 00:00:00',

PRIMÁRIA CHAVE ( `id`)

) MOTOR = InnoDB PADRÃO CHARSET = latin1 AUTO_INCREMENT = 13;

- - Laravel Learner - 608

- - Dumping dados para a tabela `role_user`

--

INSERT INTO `role_user` (` id`, `user_id`,` role_id`, `created_at`` updated_ at`)

VALORES

(1, 1, 1, '2015/03/30 15:10:21', '0000-00-00 00:00:00'),

(2, 1, 2, '2015/03/30 15:10:46', '0000-00-00 00:00:00'),

(3, 1, 3, '2015/03/30 15:10:55', '0000-00-00 00:00:00'),

(4, 10, 1, '2015/03/30 15:11:06', '0000-00-00 00:00:00'),

(5, 10, 2, '2015/03/30 15:11:22', '0000-00-00 00:00:00'),

(6, 10, 3, '2015/03/30 15:11:31', '0000-00-00 00:00:00'),

(7, 2, 2, '2015/03/30 15:11:43', '0000-00-00 00:00:00'),

(8, 2, 3, '2015/03/30 15:11:51', '0000-00-00 00:00:00'),

(9, 8, 3, '2015/03/30 15:12:38', '0000-00-00 00:00:00'),

(10, 8, 4, '2015/03/30 15:12:45', '0000-00-00 00:00:00'),

147
Capítulo 16 ■ relações eloqüentes

(11, 3, 3, '2015/03/30 15:12:53', '0000-00-00 00:00:00'),

(12, 3, 4, '2015/03/30 15:12:59', '0000-00-00 00:00:00');

/ *! 40101 SET

Character_set_client = @ OLD_CHARACTER_SET_CLIENT * /;

/ *! 40101 SET

CHARACTER_SET_RESULTS = @ OLD_CHARACTER_SET_RESULTS * /;

/ *! 40101 SET

Collation = @ OLD_COLLATION_CONNECTION * /;

// fim do role_user.SQL

Agora, antes de tudo que iria definir o método no nosso modelo User como este:

// código que começa


//models/User.php <? Php

protegidas $ tabela = 'usuários';

protected $ escondido = array ( 'password', 'remember_token');

$ timestamps públicas = false;

protegido $ fillable = matriz ( 'nome de utilizador', 'de token');

protected $ protegida = array ( 'id', 'password');

contacto função pública ()

return $ this-> hasOne ( 'Contato');

pós função pública ()

return $ this-> hasMany ( 'Post');

148
Capítulo 16 ■ relações eloqüentes

papel função pública ()

return $ this-> belongsToMany ( 'Papel');

// fim do código

Neste método:

papel função pública ()

return $ this-> belongsToMany ( 'Papel', 'Role_user');

Você pode passar explicitamente a tabela dinâmica como o segundo parâmetro. Suponha que você queira usar o nome
tabela 'users_role' em vez 'role_user'; então você pode escrever o seguinte:

papel função pública ()

retornar $ this> belongsToMany ( 'Papel', 'users_role');

É isso aí. E igualmente agora você pode usar a inversão do modelo do papel. O código é assim:

// partida código

//models/Role.php

<? Php

Papel classe estende Eloquent {

/ **

149
Capítulo 16 ■ relações eloqüentes

* A tabela de banco de dados usado pelo modelo.

* corda @var

*/

protegidas $ table = 'papéis';

user função pública ()

return $ this-> belongsToMany ( 'User');

// fim do código

Agora chegou a hora de testar o nosso código. Muitos para muitos relação funciona como uma brisa agora. O primeiro
usuário 'admin' tem três funções diferentes: Administrador, Moderador, e colaborador. Vamos verificar se em nossas rotas,
podemos obtê-lo ou não:

// //routes.php
começando código
Route :: get ( '/', function ()

$ roles = Usuário :: find (1) -> papel;

foreach ($ papéis como $ value) {

var_dump ($ value);

});

// fim do código

150
Capítulo 16 ■ relações eloqüentes

Estamos tentando descobrir que tipo de papéis que o usuário 'admin' tem. O usuário 'admin' tem três funções:
Administrador, Moderador, e colaborador. Mostrou-se até todo o modelo do usuário. Agora podemos ter uma inversão
deste modelo. Agora vamos descobrir quais usuários estão administrador ou moderador ou o Colaborador ou membro.
Como, em nossa routes.php podemos escrever o código desta forma:

// partida código

//routes.php

Route :: get ( '/', function ()

$ roles = Role :: find (1) -> user;

foreach ($ papéis como $ value) {

var_dump ($ value);

});

// fim do código

Neste código, nós realmente queremos descobrir quem são os administradores são, porque o papel ID 1 é
Administrador. Aqui estão dois usuários que são administradores. Eles são 'admin' e 'NewUser'. Os dados detalhada sobre
eles foi retirado da mesa dos usuários '. A partir da tabela 'papéis' através da Mentor, você pode procurar qualquer papel que
foi atribuído aos usuários. Não poderia haver milhares de membros ou colaboradores. Mas, em algumas linhas de códigos,
Laravel torna a sua tarefa muito mais simples. No próximo capítulo, vamos ver mais algumas características do Laravel que
lidam com banco de dados.

151
CAPÍTULO 17

Como Segurança e
autenticação trabalhar
juntos

Laravel implementa a autenticação de uma forma tão simples que você tem tudo apenas fora da caixa. Para fazer isso,
Laravel retorna uma matriz em 'app / config / auth.php' onde estas coisas são definidos e também bem documentada.
Neste arquivo, é claro que o motorista vai ser eloqüente, o modelo estará usuário, ea mesa é 'utilizadores'. Há uma outra
tabela: 'password_reminder'. Vamos discutir isso mais tarde. Então, por padrão, ele foi definido; agora tudo que você tem
a fazer é usar os métodos estáticos navios Laravel com. Para tornar a sua senha mais forte, Laravel tem classe 'Hash'
que fornece hashing Bcrypt seguro. Você pode fazer a sua senha mais forte com este método:

$ Password = Hash :: fazer ( 'yourpassword');

Podemos verificar como ele funciona. Vamos ao nosso routes.php e primeiro descobrir o que a senha do
usuário 'NewUser' é.

// partida código

//routes.php

Route :: get ( '/', function ()

$ User = Usuário :: find (10);

echo $ user -> senha;

});

© Sanjib Sinha 2017 153


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_17
Capítulo 17 ■ como segurança e autenticação trabalhar juntos

// fim do código

A saída é:

$ 2a $ 10 $ XTne1FYOoTLqGYPIiu / 7F.4AxUae9akpjpFV.xizdq3IytI9N1Nim

Fazemos esta senha com método como este password_hash PHP ():

$ User> password = password_hash ( 'pass', PASSWORD_BCRYPT);

// fim de password_has () Método

Agora podemos atualizar esta senha com método próprio Laravel Hash :: make () e ver como ele se parece.
Primeiro atualizar a senha:

// partida código

Route :: get ( '/', function ()

$ User = Usuário :: find (10);

$ User> password = Hash :: fazer ( 'pass');

$ User -> save ();

});

// fim do código

Agora a saída se parece com:

//saída

$ 2a $ 10 $ NI9gu2x3q78dzE2J.h9kweJaD4I1M27kHokiZ.yfABynpABbNA / zW

// extremidade de saída

Podemos verificar o comprimento da senha. É uma corda e comprimento é de 60. Se nós var_dump ($ user) em
nossa routes.php temos todos os detalhes sobre o usuário 'NewUser' através do modelo de usuário, ea saída irá indicar a
duração de senha.
Podemos novamente voltar para o nosso método password_hash de idade () e alterar a senha de usuário 'NewUser'
assim:

// partida código

//routes.php

154
Capítulo 17 ■ como segurança e autenticação trabalhar juntos

Route :: get ( '/', function ()

$ User = Usuário :: find (10);

$ User> password = password_hash ( 'pass', PASSWORD_BCRYPT);

$ User-> save ();

});

// fim do código

Execute o código e novamente nós var_dump ($ user) e ver a saída de senha agora:

//saída

'Password' => string

'$ 2a $ 10 $ zjBulZIfVmMZu / QDGdoCROoKlQysWs / hAVKFTGLNp60EiG5K5zl

WO'(comprimento = 60)

// extremidade de saída

A senha foi atualizado. O comprimento é de 60 qualquer forma. Você pode se perguntar por que eu gastar tanto
tempo na discussão de senhas! Primeiro de tudo, tanto quanto se trata de segurança, é preciso ter cuidado com as
senhas. Você deve torná-los mais fortes. O que eu queria provar aqui é que Laravel sempre utiliza a mais avançada
tecnologia disponível no PHP. O mesmo resultado está disponível através de código com a ajuda de Laravel. Agora
vamos tentar algum processo de autenticação usando as interfaces padrão e os métodos navios Laravel com.

A partir de encontramos alguns métodos que apontam para o processo de autenticação. Podemos usá-los no nosso modelo
User como este:

// partida código

//models/User.php

<? Php

usar Illuminate \ Auth \ UserTrait;

usar Illuminate \ Auth \ UserInterface;

usar Illuminate \ Auth \ lembretes \ RemindableTrait;

155
Capítulo 17 ■ como segurança e autenticação trabalhar juntos

usar Illuminate \ Auth \ lembretes \ RemindableInterface;

classe de usuário estende implementos Eloquent

UserInterface, RemindableInterface {

usar UserTrait, RemindableTrait;

/ **

* A tabela de banco de dados usado pelo modelo.

* corda @var

*/

protegidas $ tabela = 'usuários';

/ **

* Os atributos excluídos do formulário JSON do modelo

* matriz @var

*/

protected $ escondido = array ( 'password', 'remember_token');

$ timestamps públicas = false;

protegido $ fillable = matriz ( 'nome de utilizador', 'de token');

protected $ protegida = array ( 'id', 'password');

getAuthIdentifier função pública () {

return $ this-> getKey (); }

função pública getAuthPassword () {

return $ this-> senha;

156
Capítulo 17 ■ como segurança e autenticação trabalhar juntos

pós função pública ()

return $ this-> hasMany ( 'Post');

contacto função pública ()

return $ this-> hasOne ( 'Contato');

papel função pública ()

return $ this-> belongsToMany ( 'Papel', 'role_user');

// fim do código

Agora você pode criar um 'sistema de autenticação do tipo dashboard' para a nossa administração. É bastante simples e curto,
mas você começa a idéia e eu espero que você pode construir o seu 'CRUD' com base neste conceitos.

Agora é hora de usar 'Auth' e classe 'Session' e métodos estáticos necessárias em nosso 'routes.php' para tornar
este mecanismo de autenticação bem sucedida.

// partida código

//routes.php

:: get ( '/', 'HomeController @ home');

Route :: get ( '/ login', 'HomeController @ login');

Route :: pós ( 'login', function () {

if (Auth :: tentativa (Input :: única ( 'username', 'password'))) {

retornar Redirect :: pretendido ( '/');

157
Capítulo 17 ■ como segurança e autenticação trabalhar juntos

} outro {

retornar Redirect :: back () -> withInput () -> com ( 'erro', "Credenciais inválidas");

});

Route :: get ( 'Sair', function () {

Auth :: Sair ();

retornar Redirect :: a ( '/') -> com ( 'mensagem', 'Agora você está logado out');

});

Route :: grupo (array ( 'antes' => 'auth'), function () {

Route :: get ( '/', 'HomeController @ home');

Route :: get ( 'user / {id}', 'HomeController @ usuário');

});

// fim do código

Agora vamos explicar os passos um por um: Primeiro, precisamos ter uma página 'index' protegido. Para fazer isso tudo o
que precisamos fazer é usar o seguinte:

Route :: grupo (array ( 'antes' => 'auth'), function () {

Route :: get ( '/', 'HomeController @ home');

Route :: get ( 'user / {id}', 'HomeController @ usuário');

});

Por este encaminhamento grupo podemos definir quais páginas são apenas para usuários autenticados. Nós definimos duas páginas

como por nosso planejamento: 'index' e 'utilizadores'.

Podemos também usar o método Auth :: logout () para terminar a sessão, ele redireciona o usuário para a página de
'index' novamente, o que não é nada, mas a página de 'login'. Vamos concluir este capítulo com alguns métodos de
autenticação que os navios Laravel com por padrão. Para senhas, você pode usar estes métodos:

// partida código

Hash :: fazer ( 'yourpassword');

158
Capítulo 17 ■ como segurança e autenticação trabalhar juntos

Hash :: cheque ( 'yourpassword', $ hashedPassword);

Hash :: needsRehash ($ hashedPassword);

// fim do código

E para autenticação, você pode usar estes métodos:

// partida código

Auth :: verificação ();

Auth :: utilizador ();

Auth :: tentativa (array ( 'email' => $ email, 'password' => $ password));

Auth :: tentativa ($ UserCredentials, true);

Auth :: uma vez (UserCredentials $);

Auth :: login (usuário :: find (1));

Auth :: loginUsingId (1);

Auth :: Sair ();

Auth :: validate ($ UserCredentials);

Auth :: básica ( 'username');

Auth :: onceBasic ();

Senha :: lembrar ($ UserCredentials,

function ($ mensagem, $ user) {});

// fim do código

159
CAPÍTULO 18

Como Request, trabalho de


resposta em Laravel 5

O que faz Request significa?


Quando um usuário solicita algumas páginas, o que acontece? Você aprendeu apenas que no capítulo anterior.
Podemos obter essa instância pedido e ver como fica. Para fazer isso, gostaríamos de fazer uma espécie de tipo
insinuando nosso 'Pedido Illuminate \ Http \' classe em nosso construtor controlador ou método. Suponha que temos um
'TestController'.
Assim, o código será parecido com este:

// partida código

<? php namespace App \ Http \ Controllers;

usar Illuminate \ Http \ Request;

usar Illuminate \ Routing \ Controlador;

classe TestController estende controlador

protected $ solicitação;

/ **

* Pedido @param $ request

* Response @return

*/

testRequest função pública (Request $ request)

© Sanjib Sinha 2017 161


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_18
Capítulo 18 ■ como pedido, o trabalho de resposta no LaraveL 5

$ This-> request = $ request;

$ Uri = $ request-> path ();

var_dump ($ URI);

// código terminou

Além disso, temos uma rota em nossa 'routes.php', como este:

// partida código

get ( 'teste', 'TestController @ testRequest');

// código terminou

Agora, se vamos para o nosso navegador e digite http: // localhost: 8000 / teste obtemos uma resposta como esta:

cadeia de 'teste' (comprimento = 4)

Se digitar em nosso navegador assim:


http: // localhost: 8000 / test / hagudu / class = 5 / escola = Don 20Bosco% e no nosso nível rota passamos
mais duas variáveis ​como este:

// partida código

get ( 'test / {name} / {classe} / {} escola', 'TestController @ testRequest');

// código terminou

Nós obter uma saída como esta:

string 'test / hagudu / class = 5 / escola = Don% 20Bosco'

(Comprimento = 38)

Portanto, o seu utilizador envia um pedido e nós traçar o caminho URL através do nosso objeto de solicitação. Em Laravel 5
isto é feito por injecção de dependências. Vamos discutir isso em grande detalhe. Então, se você é um novato absoluto, apenas não
ficar com medo. Parece que podemos fazer muitas coisas através deste objeto Request. Podemos enviar algumas entradas através de
um formulário e recebê-lo no nosso perfil do usuário da atualização Controller e. Podemos gerenciar pagamentos e muitos mais.

Agora, se quiser que o caminho URL completa podemos digitar nosso controlador como este:

162
Capítulo 18 ■ como pedido, o trabalho de resposta no LaraveL 5

$ Url = $ request-> url ();

E as mudanças de saída para isto:

string 'http: // localhost: 8000 / test / hagudu / class = 5 / escola = Don% 20Bosco' (comprimento = 60)

Você começa a URL completa em vez de único caminho URI. Existem muitos métodos solicitação Você vai encontrar muito útil mais

tarde. Desde que você não começou Laravel ainda, nós não queremos que cavar muito profundo. Existem alguns métodos que você pode

apenas querer saber, como este:

$ Name = $ request-> input ( 'name');

Neste caso, você tem um nome de seus campos do formulário. Você pode obter uma matriz também, e a recuperação não é muito

complexo.

$ Input = $ request-> única ( 'username', 'password'); $ Input = $


request-> exceto ( 'CREDIT_CARD');

Neste caso, você só tem o nome de usuário e senha, exceto as informações do cartão de crédito. Há muito mais
exemplos, e nós viremos a eles quando chegar o momento adequado.

O que faz de resposta significa?


Basicamente, o que todas as rotas e controladores de enviar de volta para o navegador é Response. Os usuários enviam
pedidos eo servidor envia de volta Response. O mecanismo básico é simples o suficiente para entender o que está acontecendo
sob o capô. Laravel pode fazer muitas coisas e está equipado com várias maneiras para enviar respostas.

Mas a resposta mais importante é corda em uma rota como esta:

Route :: get ( '/', function () {

voltar 'Olá Mundo';

});

Mas isso é uma seqüência muito simples. Laravel pode fazer muito mais, como voltar para um 'Illuminate \ Http \
Response' instância ou uma visão completa. O que isso retornando um exemplo completo de Resposta "significa? Ele
realmente permite que você personalize o código de status HTTP da resposta e cabeçalhos. Um exemplo 'Resposta' herda da
'Symfony \ Component \ HttpFoundation \ Response' classe, proporcionando uma variedade de métodos para a construção de
respostas HTTP. Depois de instalar Laravel, se você abrir o diretório 'vendor / symfony', você não vai encontrar o 'Symfony \
Component \ HttpFoundation \ Response' classe que Laravel herda lá. Mas se você sempre trabalhar individualmente com e
instalar componentes 'Symfony' você vai encontrar essa classe.

O HttpFoundation define uma camada orientada a objectos para a especificação HTTP. Ele fornece uma
abstração para solicitações, respostas, arquivos carregados, cookies, sessões, et cetera. Você não vai obtê-lo dentro
Laravel, mas para o seu conhecimento e compreensão só sei que nós usamos componentes Symfony assim:

163
Capítulo 18 ■ como pedido, o trabalho de resposta no LaraveL 5

use Symfony \ Component \ HttpFoundation \ Request;

use Symfony \ Component \ HttpFoundation \ Response;

$ request = Request :: createFromGlobals ();

echo $ request-> getPathInfo ();

E usamos o objeto de resposta como esta:

$ Resposta = new Response ( 'Not Found', 404, array ( 'Tipo de Conteúdo' => 'text / plain'));

$ Resposta-> send ();

E em Laravel nós basicamente retornar resposta como esta:

usar Illuminate \ Http \ Response;

Route :: get ( 'home', function () {

retornar (novo Response ($ content, $ status)) -> header ( 'Content Type', $ value);

});

Você pode enviar uma resposta JSON como este:

Route :: get ( '/', function () {

resposta voltar () -> json ([ 'name' => 'Sanjib',


'local' => 'Pluto']);

});

E você tem uma saída como esta em seu navegador:

{ "Name": "Sanjib", "local": "Plutão"}

A saída JSON puro é um formato legível. Outro bom exemplo de resposta é Redirect. Você pode usar dois métodos
auxiliares para redirecionar os usuários conforme necessário. Quando você usa Redirecionar respostas, eles são realmente as
instâncias da classe 'Illuminate \ Http \ RedirectResponse'. Eles contêm os cabeçalhos apropriados necessários para redirecionar
o usuário para outra URL. Existem várias maneiras de gerar uma instância de 'RedirectResponse'. O método mais simples é usar
o 'redirecionamento' método auxiliar mundial:

Route :: get ( 'yourpage', function () {

164
Capítulo 18 ■ como pedido, o trabalho de resposta no LaraveL 5

regresso redireccionamento ( '/ yourpage');

});

E há também volta métodos que também vêm pronto para entregar. Se você quiser fazer seu usuário
preencher certas formas e deseja validar que com a entrada, você pode usar algo como isto:

Route :: pós ( 'seu / profile', function () {

// valida o pedido

voltar () -> withInput ();

});

Quando você aprende mais sobre as ações de roteamento e controller chamado, você pode querer usá-los como este:

voltar redirect () -> rota ( 'login');

Ou assim:

redirecionamento voltar () -> action ( 'HomeController índice @');

165
CAPÍTULO 19

Contratos comparada Fachadas

Por tão longe que você tenha entendido que o total enquadramento Laravel 5 depende de muitos blocos de interfaces,
classes e outras versões embalados que os desenvolvedores de pacotes têm desenvolvido até agora. Laravel 5 tem
felizmente os usou, e eu encorajo-vos a fazer o mesmo, seguindo o princípio sólida e baixo acoplamento. Para dominar o
quadro corretamente, você precisa entender os principais serviços que são executados Laravel 5. Quais são os principais
recursos por trás da cena? Basicamente, Contratos vir entre em relação a este cenário. Contratos são interfaces que
fornecem esses serviços básicos. Como 'Illuminate \ Contratos \ Mail \ Mailer' define o processo de envio de mails e fazendo
isso, essa interface simplesmente piscinas na implementação de classes mailer alimentado pelo SwiftMailer. Agora, o que
são os 'Fachadas'? título deste capítulo é 'Contratos vs. Fachadas'. Será que eles têm qualquer semelhança ou relação ou
qualquer outra coisa? Deixe-me falar alguma coisa sobre Fachadas em primeiro lugar.

Fachadas também são interfaces. Mas eles têm uma diferença distinta de Contratos. Primeiro de tudo, Fachadas são
interfaces estáticas que fornecem métodos para as classes de contêiner de serviço. Você já viu um monte de Fachadas já.
Lembre-se 'App', 'Route', 'DB', 'Ver', et cetera. A principal qualidade de Fachadas é que você pode usá-los sem indicação de
tipo. Como em seu arquivo 'routes.php' você pode escrever o seguinte código:

Route :: bind ( 'livros', function ($ id) {

voltar App \ Livro :: onde ( 'id', $ id) -> first ();

});

Este 'Route' Fachada resolve diretamente os contratos fora do recipiente serviço. Embora Fachadas são interfaces
estáticas, eles têm sintaxes mais expressivas e fornecer mais capacidade de teste e flexibilidade do que a metodologia
tradicional estático. Mas a vantagem de 'contratos' é que você pode definir dependências explícitas para as suas aulas e fazer a
sua aplicação mais baixo acoplamento. Claro que, para a maioria das aplicações Fachadas funcionar bem. Mas, em alguns
casos, se você quer inovar algo mais, você precisa usar Contratos. Como você poderia implementar um contrato? É
extremamente simples e um exemplo pode iluminar todo o conceito. Na verdade, você tê-lo usado já! Suponha que você tenha
um 'BookController' através do qual você quer manter uma longa lista de seus livros favoritos. Para fazer isso você precisa para
armazenar livros no banco de dados. Para fazer isso você pode ligar o seu Modelo 'Livro' no seu 'routes.php' primeiro, e em
seguida, usando recursos que você pode fazer todos os tipos de operações CRUD. Ao fazer isso, você precisa fazer login.

© Sanjib Sinha 2017 167


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_19
Capítulo 19 ■ Contratos comparada fachadas

Considere este código:

loja de função pública (Request $ request)

if (Auth :: cheque ()) {

// O usuário está logado

Você pode verificar se o usuário está logado ou não. E dependendo de que você pode adicionar apenas seus livros
favoritos. Para verificar que você usa 'Auth' fachada. Isso é bom; Contanto que você não quer estado mais dissociado ele
funciona muito bem. Mas se você preferir seguir o princípio sólida e quer um Estado mais dissociada então, em vez de
depender de concreção você deve adotar uma abordagem abstrata mais robusto. E, nesse caso, contrato vem a seu
salvamento. O próprio Taylor Otwell mantém repositórios git hub sobre Contratos, então é melhor você ter um olhar em
torno dele. Todos os contratos Laravel viver lá:

https://github.com/illuminate/contracts

Agora voltemos ao nosso tema anterior. Assim, podemos usar tanto o nosso 'Auth' fachada. Mas tentar entender
uma coisa; quando você usa fachada ele assume a estrutura e está muito intimamente ligado com uma concreção. Mas,
considerando o princípio sólido, você quer um estado dissociado. O que fazer? Vamos considerar outro cenário. Nós
podemos injetar nosso 'Auth' Fachada através construtor como este e reescrever todo o nosso código desta forma:

usar Illuminate \ Http \ Request;

usar o App \ Http \ Requests;

usar App \ Http \ Controllers \ Controlador;

usar Illuminate \ Auth \ Guarda como Auth;

classe BooksController estende controlador

/ **

* Exibir uma lista do recurso

168
Capítulo 19 ■ Contratos comparada fachadas

* Response @return

*/

protected $ auth;

__construct função pública (Auth $ auth) {

$ This -> auth = $ auth;

loja de função pública (Request $ request)

$ This-> Auth-> tentativa ();

Agora você pode opinar que é muito melhor como temos injetado instância 'Auth' através do nosso
construtor. Sim, é melhor do que antes, mas ainda lhe falta o princípio design sólido. Ela depende de uma classe
concreta como o seguinte:

namespace Illuminate \ Auth;

usar RuntimeException;

usar Illuminate \ Support \ Str;

usar Illuminate \ Contratos \ Eventos \ Dispatcher;

usar Illuminate \ Contratos \ Auth \ UserProvider;

use Symfony \ Component \ HttpFoundation \ Request;

use Symfony \ Component \ HttpFoundation \ Response;

usar Illuminate \ Contratos \ Auth \ Guarda como GuardContract;

usar Illuminate \ Contratos \ Cookies \ QueueingFactory como Cookiejar;

usar Illuminate \ Contratos \ Auth \ autenticáveis ​como UserContract;

use Symfony \ Component \ HttpFoundation \ Session \ SessionInterface;

169
Capítulo 19 ■ Contratos comparada fachadas

classe Guarda implementa GuardContract {....}

// código é incompleta por brevidade

Como você vê, quando usamos esta linha de código em nosso 'BookController': usar Illuminate \ Auth \ Guarda como Auth,
nós realmente injetar uma instância com base na concreção não abstração. Quando unidade testar o nosso código, nós vamos ter
que reescrever os nossos códigos. Além disso, sempre que você chamar quaisquer métodos através deste exemplo, é consciente do
seu quadro. Mas precisamos torná-lo completamente inconsciente do nosso quadro e tornar-se fracamente acoplada. Para fazer
isso, só temos de mudar uma linha de código em nosso 'BookController'.

Em vez de essa linha de código:

usar Illuminate \ Auth \ Guarda como Auth;

Nós escrevemos esta linha de código:

usar Illuminate \ Contratos \ Auth \ Guarda como Auth;

E é isso! Agora o nosso exemplo 'Auth' é completamente baixo acoplamento. E agora nós podemos mudar essa
linha de código na loja () método:

if (Auth :: cheque ()) {

// O usuário está logado

a esta linha de código:

$ This-> Auth-> tentativa ();

E isso é feito. Agora o aplicativo alcançou mais sofisticação, seguindo o princípio de design sólido e torna-se
completamente de baixo acoplamento. Finalmente, se fôssemos para verificar a interface Illuminate \ Contratos \ Auth \
Guarda, o que vemos? Basta dar uma olhada, para que você possa entender o que acontece nos bastidores. O código
dessa interface é muito grande, portanto, para brevidade, basta cortar o método de tentativa () fora dele. A interface se
parece com isso:

namespace Illuminate \ Contratos \ Auth;

Guarda de interface

/ **

* Tentar autenticar um usuário usando as credenciais


fornecidas.

170
Capítulo 19 ■ Contratos comparada fachadas

* @param array $ credenciais

* @param bool $ lembrar

* @param bool $ login

* @return bool

*/

tentativa função pública (array $ credenciais = [], $ lembrar = false, $ login = true);

.....

// este código é incompleta

Agora o seu código não é acoplado a qualquer fornecedor ou até mesmo para Laravel. Você não está obrigado a seguir uma

metodologia rigorosa de uma classe concreta. Você pode simplesmente implementar sua própria metodologia, alternativa fora de qualquer

contrato.

Espero que esta comparação entre “contrato” e “fachada” faz sentido.

171
CAPÍTULO 20

Middleware, camada de filtro, e


segurança extra

HTTP Middleware é uma das melhores instalações Laravel 5 navios com. Ele não só adiciona segurança extra para a sua
aplicação, mas também dá-lhe liberdade suficiente para criar o seu próprio mecanismo de segurança ao lado do mecanismo
de autenticação Laravel padrão. Como você já sabe, quando um usuário solicita para uma página, o navegador envia o
pedido e o servidor responde. Às vezes, esse mecanismo pedido de resposta é simples e às vezes é bastante complicado.
Mas no final do dia sempre que um usuário solicita uma página de um pedido HTTP entra em sua aplicação. Na maioria das
vezes isso é inócuo, mas como diz o provérbio que você não pode e não deve confiar na entrada ou solicitação do usuário
para que ele precisa filtrada. Tem que ser filtrada quando seu aplicativo precisa de um pouco mais de medidas de
autenticação ou de segurança a tomar. Middleware faz isso fora da caixa.

Laravel 5 navios com middleware 'Authenticate'. É padrão para que você não precisa ajustá-lo para adicionar alguma
segurança extra para a sua aplicação. O mecanismo é muito simples. Ele verifica as credenciais do usuário e permita que
efectue a sua aplicação e prosseguir. Mas além deste padrão Middleware podemos adicionar nossas próprias
funcionalidades.
Em seguida, no nível de construí-la instancia esta 'auth' de modo que na função pega ele pode verificar se o
usuário é um convidado ou um usuário autenticado. A tarefa bastante simples, mas há algo mais. Nessa pasta, há um
outro arquivo: 'RedirectIfAuthenticated. php'. Vamos ver o seu código também:

<? Php

namespace App \ Http \ Middleware;

Encerramento usar;

usar Illuminate \ Contratos \ Auth \ Guarda;

classe RedirectIfAuthenticated

/ **

© Sanjib Sinha 2017 173


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7_20
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

* A implementação Guard.

* Guarda @var

*/

protected $ auth;

/ **

* Criar uma nova instância de filtro.

* @param Guarda $ auth

* vazio @return

*/

função pública __construct (Guarda $ auth)

$ This-> auth = $ auth;

/ **

* Lidar com uma solicitação de entrada.

* @ param \ Illuminate \ Http \ Request $ request

* @ param \ Encerramento $ próximo

* @return misturada

*/

identificador de função pública ($ request, Encerramento $ seguinte)

174
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

if ($ this-> Auth-> cheque ()) {

voltar redirecionamento ( '/ home');

retornar $ seguinte ($ request);

Ele faz quase a mesma coisa. Ele está verificando a autenticação do usuário e permite que ele vá para o local
desejado. Aqui está:

1. if ($ this-> Auth-> cheque ()) {

2. voltar redirecionamento ( '/ home');

3. }

Agora, a pergunta é, como é que funciona fora da caixa? Para descobrir a nossa resposta, precisamos ir à nossa
página 'routes.php'. Aqui já vimos como podemos usar o processo 'login, logout, e registrar' usando o mecanismo de
autenticação padrão. Fazendo isso, tivemos que escrever um pedaço de código como este:

1. Route :: grupo ([ 'middleware' => 'auth'], function () {

2. Route :: get ( 'home', function () {

3. regresso vista ( 'auth.home');

4. });

5.
6. Route :: get ( 'dashboard', function () {

7. regresso vista ( 'auth.dashboard');

8. });

9.});

Você atravessa a primeira linha e espero que agora faz sentido com a lógica Middleware padrão. No
nosso Grupo Rota, usamos

[ 'Middleware' => 'auth']

175
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

E distante conecta com a autenticação Middleware embutido. Na verdade ele é definido em 'app / Kernel.php'
como uma propriedade protegida.

1./**

2. * middleware rota do aplicativo.

3. *

4. * matriz @var

5. */

6. protected $ routeMiddleware = [

7. 'Auth' =>
\ App \ Http \ Middleware \ Autenticação :: class,

8. 'Auth.basic' =>
\ Illuminate \ Auth \ Middleware \ AuthenticateWithBasicAuth :: class,

9. 'Guest' =>
\ App \ Http \ Middleware \ RedirectIfAuthenticated :: class,

10.];

Como o padrão Authenticate Middleware funciona é agora claro compilado. Como sobre a adição de algumas nossas próprias
funcionalidades? Vimos no capítulo de autenticação que um usuário faz login e ela vai para o '/ dashboard'. Bem, nós precisamos
adicionar algumas funcionalidades extras em nossa tabela 'utilizadores' em primeiro lugar, de modo que um dos usuários será o
administrador e só ela pode verificar em uma página de 'blog'.

Desde precisamos testar nossa própria Middleware para o chão Laravel, decidimos torná-lo o mais simples. Assim,
mantemos um link para a página 'Blog' na página nosso 'Painel'. Agora cada usuário faz login e clicar nesse link. Mas
nosso Middleware irá verificar se o usuário é administrador ou não. Se ela for um administrador, ela pode pousar na página
'Blog' com poder administrativo especial, e se ela não for, ela vai enviado de volta para a página inicial para usuários em
geral. Este é o nosso simples administrador do edifício Middleware passo processual. Deixe-nos começar.

Primeiro, precisamos configurar uma coluna extra na nossa célula da tabela 'utilizadores'. Precisamos migrar para isso. Você pode

fazê-lo manualmente no seu PHPMyAdmin ou diretamente usar Tinker para adicionar essa coluna. Mas a migração é mais simples.

Abra o terminal, vá ao nosso aplicativo Laravel, e emitir este comando:

php artesão marca: a migração add_is_admin_to_user_table -artefatos de uso doméstico = usuários

176
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

Vá para a pasta de base de dados e ver que sua nova migração foi criado. Agora antes de migrar começa
precisamos ajustar o método () para cima () e para baixo como este:

1. <? Php

2.

3. Uso Illuminate \ Database \ Schema \ Blueprint;

4. uso Illuminate \ Database \ Migrações \ Migration;

5.

6. classe AddIsAdminToUserTable estende migração

7. {

8. / **

9. * Executar as migrações.

10. *

11. * vazio @return

12. */

13. função pública para cima ()

14. {

15. Schema :: mesa ( 'usuários', function ($ table Blueprint) {

16. $ Table-> booleano ( 'is_admin') -> padrão (false);

17. });

18.}

19.

20. / **

21. * Inverta as migrações.

22. *

177
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

23. * vazio @return

24. */

25. função pública para baixo ()

26. {

27. Schema :: mesa ( 'usuários', function ($ table Blueprint) {

28. $ Table -> dropColumn ( 'is_admin');

29. });

30.}

31.

Agora estamos prontos para migrar, então emitir este comando:

php migrar artesão

Verifique se o seu tabela 'utilizadores'; você verá que uma coluna extra já foi adicionado, e cada um é falso. Então você
escolher qualquer um usuário e fazê-la o administrador para que, quando verificar a autenticação ele sai verdade. Nossa
configuração de banco de dados está pronto. Agora podemos prosseguir para a próxima etapa. Esta etapa envolve a criação de
nossa própria lógica Middleware que irá verificar se o usuário é administrador ou não. Se ela é o administrador, ela pode ir a
página 'Blog'. Caso contrário, ela será enviada de volta para a página inicial para usuários em geral. Nós podemos criar a nossa
Middleware personalizado através do console. No nosso terminal, emitimos este comando:

php artesão marca: RoleMiddleware middleware

Como você vê, nós nomeamos nosso Middleware 'RoleMiddleware'. Você pode nomeá-lo de forma diferente. Sem
problemas. Ele vai disparar imediatamente de volta com um aviso que diz que seu middleware foi criado com sucesso. Vamos a
pasta 'app / HTTP / Middleware' e verificá-lo. Sim, ele foi criado. Se trata-se com um método de punho (), como de costume. Agora
tudo o que precisamos é adicionar esta linha de código na parte superior da primeira página:

usar Illuminate \ Contratos \ Auth \ Guarda;

Temos de verificar a autenticidade do usuário. O código completo fica assim:

1. <? Php

178
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

2.

3. namespace App \ Http \ Middleware;

4. Uso Encerramento;

5. Use Illuminate \ Contratos \ Auth \ Guarda;

6. Uso Illuminate \ Http \ RedirectResponse;

7. // usar App \ User;

8.

9. classe RoleMiddleware

10.

11. protected $ auth;

12.

13. __construct função pública (Guarda $ auth) {

14. $ This -> auth = $ auth;

15.}

16.

17.

18. / **

19. * Lidar com uma solicitação de entrada.

20. *

21. * @ param \ Illuminate \ Http \ Request $ request

22. * @ param \ Encerramento $ próximo

23. * @return misturada

24. */

179
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

25. identificador de função pública ($ request, Encerramento $ seguinte)

26. {

27. if ($ this-> Auth-> verificação ())

28. {

29. if ($ this-> Auth-> user () -> is_admin == TRUE)

30. {

31. retornar $ seguinte ($ request);

32. }

33. }

34.

35. retornar nova

RedirectResponse (url ( '/ auth / login'));


36.}
37.

38.}

Linhas 27 e 29 são muito importantes; na verdade, em última análise, desempenha o papel crucial na nossa própria Middleware.

A lógica é bastante simples. Nossa classe 'RoleMiddleware' é chamado sempre que uma instância de 'Guard' é criado e
que vai cuidar de mais processo de autenticação. Assim, em nosso método pega () que passa dois parâmetros, 'pedido' e
'Encerramento $ próximo', vamos adicionar algumas especiarias extras para que quando ele verifica as credenciais do usuário,
ele olha para cima e pergunta se ela é o administrador. Se não, ele envia-a de volta para a página de login. Então, se alguém
apenas digita o URL e tentar entrar em nossa página 'Blog' ela será enviada de volta para a página de login. Agora, se ela é
um usuário registrado, ela pode entrar, mas acaba na página 'Painel'. Para facilitar este 'RoleMiddleware' precisamos adicionar
um extra grupo Route em nossos 'rotas. arquivo php' assim:

1. Route :: grupo ([ 'middleware' => 'auth'], function () {

2. Route :: get ( 'home', function () {

3. regresso vista ( 'auth.home');

4. });

180
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

5.

6. Route :: get ( 'dashboard', function () {

7. regresso vista ( 'auth.dashboard');

8. });

9.});

10.

Route :: grupo ([ 'middleware' => 'papel'], function ()

11.

12. Route :: get ( 'blog', function () {

13. regresso vista ( 'blog.index');

14. });

15.

16.});

Você vê na linha 10, nós adicionamos um extra Route Grupo Middleware, 'papel'. Mas a questão é como a nossa aplicação
vai aprender sobre isso. Ok, nossos passos têm sido incompleta até agora. Nós precisamos registrá-lo para 'app / Kernel' para que o
código 'app / Kernel.php' se parece com isso:

1. protegidos $ routeMiddleware = [

2. 'Auth' => \ App \ Http \ Middleware \ Autenticação :: class,

3. 'Auth.basic' => \ Illuminate \ Auth \ Middleware \


AuthenticateWithBasicAuth:

:classe,

4. 'Guest' => \ App \ Http \ Middleware \ RedirectIfAuthenticated :: class,

5. 'Iplog' => \ App \ Http \ Middleware \ RequestLogger :: class,

6. 'Papel' => \ App \ Http \ Middleware \ RoleMiddleware :: class,

7.];

181
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

Atente para a linha 6. Registramos nosso

'Papel' => \ App \ Http \ Middleware \ RoleMiddleware :: class,

E agora irá funcionar como uma brisa. Os próximos passos são deixados para criar um controlador e exibição página.
Que você pode fazer. No próximo capítulo vamos lançar oficialmente uma instalação de administrador e vai criar um painel
administrativo em que um administrador pode criar, editar e excluir usuários.

Até agora você viu como podemos controlar o acesso aos usuários usando vários tipos de Middleware. Use sua
imaginação para construir todo o Middleware louco, eo procedimento é bastante simples. Você pode lidar com isso por si
mesmo. Suponha que queremos verificar os pontos usuários ganharam em um fórum. Podemos fazer alguma equipe mais
estranho como verificar se um nome de usuário começa com qualquer carta particular, et cetera. Podemos usar 'antes' e
'depois' Middleware para que a nossa aplicação irá lidar com algo de antemão e executar alguma coisa depois.

Suponha que queremos verificar os pontos fórum de um usuário. Podemos criar um Middleware como este:

1. namespace App \ Http \ Middleware;

2.

3. Encerramento usar;

4.

5. classe PointMiddleware

6. {

7. / **

8. * Execute o filtro pedido.

9. *

10. * @param

\ Illuminate \ Http \ Request $ request

11. * @ param \ Encerramento $ próximo

12. * @return misturada

13. */

14. identificador de função pública ($ request, Encerramento $ seguinte)

182
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

15. {

16. if ($ request-> input ( 'ponto') <= 500) {

17. voltar redirecionamento ( 'home');

18. }

19.

20. retornar $ seguinte ($ request);

21. }

22.

23.

Agora também podemos lidar com isso antes e depois como este:

1. namespace App \ Http \ Middleware;

2.

3. Encerramento usar;

4.

5. classe BeforeMiddleware

6. {

7. identificador de função pública ($ request, Encerramento $ seguinte)

8. {

9. // Executar a ação

10.

11. retornar $ seguinte ($ request);

12. }

13.}

183
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

14.

namespace App \ Http \ Middleware;

15.

16. Encerramento usar;

17.

18. classe AfterMiddleware

19. {

20. identificador de função pública ($ request, Encerramento $ seguinte)

21. {

22. $ Resposta = $ seguinte ($ request);

23.

24. // Executar a ação

25.

26. retornar $ resposta;

27. }

28.}

Portanto, há muitas ações à espera de ser explorado dentro desta secção Middleware. Concluiremos com um
middleware de registro que irá registrar todos os pedidos que chegam ao seu aplicativo: muito simples e elegante. Você
aprendeu como criar um Middleware. Portanto, criar um 'IPLogger' Middleware primeiro. E adicionar uma linha de código
em seu método handle () como este:

1. <? Php

2.

3. namespace App \ Http \ Middleware;

184
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

4.

5. Uso Encerramento;

6.

7. classe IPLogger

8. {

9. / **

10. * Lidar com uma solicitação de entrada.

11. *

12. * @ param \ Illuminate \ Http \ Request $ request

13. * @ param \ Encerramento $ próximo

14. * @return misturada

15. */

16. identificador de função pública ($ request, Encerramento $ seguinte)

17. {

18. \ Log :: info ($ request -> getClientIp ());

19. retornar $ seguinte ($ request);

20.}

21.

Em seguida em sua 'routes.php' adicionar este grupo Middleware:

1. Route :: get ( '/', [ 'middleware' => 'iplog', function ()

2. regresso vista ( 'index');

3.}]);

185
Capítulo 20 ■ Middleware, camada de filtro, e segurança extra

De modo que cada vez que um usuário envia a solicitação para a página de índice, o seu 'endereço IP' será armazenado no

'armazenamento / logs / laravel.log' assim:

1. [2015 08 22 18:16:14] local.INFO: :: endereço ip

2. [2015 08 22 18:16:55] local.INFO: :: endereço ip

Devo mencionar que você deve ter registado o seu 'IPMiddleware' em 'app / HTTP / Kernel.php' assim:

'Iplog' => \ App \ Http \ Middleware \ IPLogger :: class,

E isso é feito!
Por favor, dê uma olhada na documentação para entradas mais valiosos como parâmetros middleware e
Terminável Middleware, onde você iniciar uma sessão, que é armazenado e terminada após a sua tarefa foi
cumprida.

186
Índice

classe Controller, 29
??????????????????
UMA
controlador, 35 COI recipiente, e a interface,
Abstracção, 18 35 camadas, 29
funções anônimas, 28
Autenticação e autorização, 81 MyController.php arquivo, 30-31 visualização da
AuthController, 81-84 config / app.php, 81 página, 31 de camada de apresentação, 29 de
da base de dados / ficheiros de migração, controlador de recursos, 34 RESTful, 32 papel, 33
85 login.blade.php, 85-86, 88-89 opção arquivo routes.php, 29-30 Cross-site request forgery
Sair, 89-90 validador método (), 84 (CSRF), 25 CRUD (criar, recuperar , update, delete)

??????????????????
B
aplicação, método 59 controlador, 70
Lâmina. Vejo Pontos de vista e lâmina create.blade.php, 74-76 criação (página de revisão),
página 74 edição, 77, 79 página editreview.blade.php,
76 página index.blade.php, 70-72 página de índice,
??????????????????
C
79 vista página, 76 página de revisão, 70, 72 arquivo
Compositor review.php, 68 arquivo routes.php, 73, 76
centralmente / globalmente, 2 show.blade.php, 73 arquivo table.php, 67-68 arquivo
comandos, 2-3 tipo de arquivo, TaskController.php, 68, 69, 72 , 74 função URL, 72
3 globalmente, 4 home page, 1

instalação de Laravel 5.3, conexão 4


Internet, 4 Laravel 5,2, 3 localmente,
2

pacote de monólogo, 3
página inicial, 1-2 Contratos vs. fachadas

tentativa () método, método 170 ??????????????????


D
LivroController, 170, 167 operações migração de banco de dados, 49
CRUD interfaces 167 vantagem, 49
. arquivo env, comando 49 migrar,
princípio SÓLIDO, método arquivo de 51 PHP, 50-51

168-169 loja (), 170

© Sanjib Sinha 2017 187


S. Sinha, Começando Laravel, DOI 10,1007 / 978-1-4842-2538-7
■ ÍNDICE

migração de banco de dados ( cont.) User.php, 125-126 var_dump método


ferramenta phpMyAdmin, mesa de (), 135-136
52 tarefas, 50
-se e função, mesa de 50 usuários, 49
para baixo
??????????????????
F, G
Fachadas, estrutura
167 Arquivo
??????????????????
E pasta APP, 15 de pasta de
relações eloqüentes inicialização, pasta base de dados 16,
vantagem de, método 128 16 home page, 17 instalação, 16 de
belongsTo (), método 141 pedaço interfaces e método, 19 Laravel 5.3.18,
(), 133 classe contacto, 126-127 15 de pasta pública, 16 principais
contacto () método, 140 contactos design sólido, 17 Formas, 65
detalhes, tabela 131-132
contactos, 129 criação, 53 cerne,
132

alias de matriz, matriz 65


funções da base de dados da tabela, 57, 124 prestadores, 65
definição, 123 de classe vazio, 56

código final fonte, 137, 139 ??????????????????


H
função (), 129 Herdade
hasMany método (), 143-144 hasOne () seção de pasta e local, 11 arquivo
método, 139, 143 de inserção, actualização / Homestead.yaml, 10 instalação e
apagar, 133-134 de interface, 54 e formato configuração, 10 test.app, 13 caixa de
JSON Vagrant e Vagrant, 9 errante até de
comando, 12
de saída, 128
atribuição em massa, 56, classe 127
modelo, 53
método NewUser, 134, 142-143 ORM, ??????????????????
I, J, K
123 Interfaces e injecção método, 19
resultado de saída, 129-131
arquivo PHP, 53
tabela mensagens, 144-145 ??????????????????
eu
propriedades, 127, 136 papel método (), Laravel herdade, 7
149-150 tabela role_user, 145-149
routes.php, 125, 140, 151 excepto
método (), 54-55 serializar () e ??????????????????
M
unserialize () Middleware, filtra-se e camada
segurança, 173 app / arquivo Kernel.php,
métodos, 129 176, 181 autenticação, 173 página do blog, 176
instrução SQL, de criação de nível de construção, método 173 pega (),
141 mesas, mesa de 123 178-180, 184-185 middleware, 182-184
tarefas, 54 tipos de, 123 RedirectIfAuthenticated.php, 173

actualização () método, classe


55 utilizador, 124-125

188
■ ÍNDICE

RoleMiddleware, 178
??????????????????
S, T, U
arquivo routes.php, método 175, 180-181, 185 de
armazenamento / logs / laravel.log, 186 para cima () e para Segurança e autenticação, 153
baixo (), 177-178 Modelo, vista, controlador de fluxo de Auth, 158-159 página de índice, o método

trabalho e, 59 158 make (), método 154 método NewUser,

tudo () método, 60 arquivo routes.php, 153 password_hash (), 154 mesa

59 página task.blade.php, 61 arquivo password_reminder, 153 routes.php, mesa

TaskController.php, 60 tarefa classe de modelo 157-158 usuário, 155-157 método

modelo, 60 var_dump, 155 princípio de design SOLID ,


banco de dados SQLite 17, 63

metodologia MVC, 123

??????????????????
NÃO
rotas nomeadas, 26 arquivo database.sqlite, 64
. arquivo env, 63 caminho de
arquivo, 63 staticmethod. Vejo Routing
??????????????????
P, Q
PHP 5, 19

??????????????????
VWXYZ
??????????????????
R
Errante, 7. Veja também Validação
Estado representacional Homestead
Transferência (DESCANSO), action.php, 96 regras condicionais,
32 Pedido 112-113 validação personalizada,
significado, 161 de 113-118 mensagens de erro, variável de
saída, 163 erro 104-107 $, 109 formulário, 91-92
TestController, 161-162
caminho URI, 163 controlador
Versátil, método 34 Response validação, 119-120, 122 página de
visualização, 93 significado, classe 91
componentes, 163 método MyCustomValidation, 117 parâmetros, 105
auxiliar, 164-165 JSON, 164 register.blade.php, 108-109 arquivo
significado, 163 de saída, 164 registration.blade.php, 92 regras, 110-112
código-fonte, 97-103 validar classe .php,
94-95 e exibições de lâmina
função do trajecto (), 163 função
returningASimplePage, 30 Encaminhamento, 21

funções anónimos, 21, 28 qualquer


método (), 25 arquivo about.blade.php, 43, 44 método
app / HTTP / routes.php arquivo, 21 compacto, código de estilo CSS 45, 42
melhores oractices, 25 conceito, 28 de estilo passado dinamicamente dados, 46 código
CSS, 22 código HTML, 22 de protocolo master.blade.php, código 41 MyController,
HTTP, 21 métodos, 24 rotas nomeadas, 26 45 processos, 41 caixa virtual, 7
organizar arquivos, arquivo de 27 routes.php,
21, navegador web 24 , 23

seção de download, 8 instalação, 7


Kali Linux e Windows XP, software 9
UBUNTU, 8

189