Para instalar o laravel temos que entrar no site https://laravel.

com/ ir em documention e depois escolher qual a

versão a ser instalada. Procurar dentro da installation a linha de comando para realizar a instalação do pacote.

Para instalar a versão mais nova sem criar um projeto:

composer global require laravel/installer

Once installed, the laravel new command will create a fresh Laravel installation in the directory you specify. For
instance, laravel new blog will create a directory named blog containing a fresh Laravel installation with all of
Laravel's dependencies already installed (trocar o nome blog pelo nome do seu projeto novo):

laravel new blog

Para instalar uma versão específica em um projeto podemos utilizar um comando alternativo dependendo da versão
escolhida, abaixo temos exemplos:

composer create-project --prefer-dist laravel/laravel:^7.0 blog

composer create-project --prefer-dist laravel/laravel blog "6.*"

composer create-project --prefer-dist laravel/laravel blog "5.8.*"

Para rodar o projeto na máquina local utilizar:

php artisan serve

Um controlador guarda as funções básicas a serem criadas em uma aplicação nova.

Para criar um controller com as funções básicas do CRUD:

php artisan make:controller NomedoController --resource

Após fazer o login irá aparecer a página home (seu código está no arquivo home.blade.php)
Para incluir ou apagar código dessa página é só entrar em um editor web e realizar a alteração. Todo código deve
estar dentro da seção @section(‘content’).

Para que apareça uma nova página do projeto temos que:

1. Editar a página do controller criada anteriormente (ex. TarefasController.php) e em public function index()
colocar o código de retorno da página a ser criada.
 2. Em resources – views, devemos criar a página a ser exibida com o mesmo nome que foi colocado no
controller anterior (obrigatório colocar o blade.php). Ex. tarefas.blade.php
Nessa página você pode colocar o código do seu projeto.

3. Em routes editar o arquivo web.php e incluir a rota para a nova página criada anteriormente juntamente
com o nome do controller relacionado a ela.
Em um projeto que você não conhece é só entrar no arquivo web.php e observar as routes para saber como
acessar pelo navegador esse projeto.
Para sabermos quais as rotas que existem na aplicação utilizamos:

php artisan route:list

4. Abrir a nova página no navegador para teste.

Com a nova página pronta você poderá editá-la e incluir os links dos componentes (CSS e JS) que devem ser copiados
do site do bootstrap em: https://getbootstrap.com.br/docs/4.1/getting-started/introduction/

Esses links irão direcionar a formatação de botões, caixas de texto, etc para o servidor padrão onde se encontram os
códigos css e js. Você poderá copiar esse link no navegador e depois salvar o conteúdo em um arquivo com o mesmo
nome que está no link para dentro de uma pasta no seu computador e alterar o endereçamento do link para esse
novo arquivo, com isso se a internet parar a sua aplicação não irá ficar desconfigurada.
Antes da edição você deve copiar uma parte do código @extendes... de home.blade.php para a página criada (Ex.
tarefas.blade. php) e depois incluir os links.

Colocar dentro da @section('content') o código do formulário a ser utilizado (pode ser do bootstrap ou de outros).
Código copiado do bootstrap:
Após isso é só realizar as alterações no formulário conforme a sua aplicação.

Para criar uma tabela no banco de dados podemos usar as migration, onde vai ser criado em database – migrations
um arquivo que irá gerar a nova tabela:

php artisan make:migration create_tarefas_table

Ao editar o arquivo create_tarefas_table você verá o código básico para a criação automática da nova tabela,
podendo ser alterado com a inclusão de novos campos e relacionamentos.
O nome da tabela a ser criada é o mesmo do nome do meio do arquivo create_tarefas_table.

Ao clicar em “enviar” a aplicação vai no arquivo web.php dentro de routes procura a rota “tarefas” e se encontrar é
redirecionada para o arquivo TarefasController.php que dentro dele a aplicação enviará os dados do formulário para
a validação e depois de serem validados, esses dados vão ser incluídos na tabela do BD.

Se retornar a msg de erro que o sql não encontra o dado a ser incluído pois o campos está nulo devemos verificar no
código do formulário se os campos estão nomeados.
Ex. <input type=”text” class=”form-control” id=”nome” name=”nome” ……
Após a edição do arquivo você deve gerar a tabela utilizando o comando abaixo e depois verificar no banco de dados
se foi criada a tabela:

php artisan migrate

Models, dentro da arquitetura MVC, são classes responsáveis pela leitura, escrita e validação de qualquer dado. Por
isso, será aqui que iremos trabalhar com Eloquent para fazermos todo tipo de ações no nosso banco de dados.
Porém, primeiro vamos entender o que é o Eloquent.
Eloquent nada mais é que um ORM que vem em conjunto com o Laravel. Ele possui uma estrutura bem simples para
você realizar a implementação da sua lógica de controle com banco de dados.
Com base nos preceitos do ORM (Object Relational Mapping), o Eloquent abstrai toda a complexidade da interação
com os bancos de dados utilizando as Models para interagir com cada tabela.
Para facilitar o trabalho, com ele existem algumas convenções, como:
 Os nomes de tabelas são padronizadas para o plural da classe que irá consumi-la.
 As Primary keys são sempre vinculadas à uma coluna id.
 Toda tabela possuirá colunas timestamp mostrando a data de criação (created_at) e data de atualização
(updated_at).
 Por padrão, as Models do Eloquent irão buscar as configurações de conexão com o banco de dados no
arquivo padrão do Laravel, “config/database.php”.
Criar um model:

php artisan make:model Tarefas

Copiar o código do user.php e colar no model criado, trocar o nome da class para o nome do model, mudar o
extends para Model e alterar o restante do código conforme o seu projeto.

protected $fillable cria um array com os valores dos campos nomeados.

Com o protected $table a o código da aplicação vai procurar o nome da tabela do BD dentro da variável $table.

Agora temos que ir no controller e editar a public function store(Request $request) para inserir o código para realizar
a validação dos dados $validator = Validator::make($request->all() e a inserção dos dados no BD.
Criação de API que irá mostrar todas as tarefas:

Criar um controller dentro de uma pasta:

php artisan make:controller "Api\TarefasController"

Com isso o laravel irá criar uma pasta chamada Api e o arquivo TarefasController.php dentro de controllers e um
outro arquivo chamado api.php dentro de routes.
Depois colocar no código qual a model da aplicação, criar uma function index() para retornar todas as tarefas do BD.
No arquivo api.php devemos apagar o código de exemplo e inserir o código novo para que a aplicação seja
direcionada para o arquivo Api\TarefasController e o controller gerar a visualização das tarefas que estão
armazenadas no BD.

Ao digitar o endereço no navegador vamos ter a resposta abaixo:

Para visualizar os registros da tabela do BD na página home devemos inserir o código no arquivo
HomeController.php e depois no home.blade.php:
INSTALAÇÃO DO PACOTE ADMINLTE:

Para instalar o pacote https://github.com/jeroennoten/Laravel-AdminLTE devemos primeiramente instalar a

autenticação do laravel:

Até a versão 5.9 utilizar php artisan make:auth

(For Laravel 7+ only) If you want to install the authentication scaffolding, then require the laravel/ui package using
composer:
composer require laravel/ui
php artisan ui vue –auth

Para criar uma nova aplicação com a autenticação incluída utilize:

laravel new blog --auth

Criar o banco de dados da aplicação para serem migradas as tabelas do sistema de autenticação.
Editar o arquivo .env e colocar as configurações do servidor e banco de dados criado.

Depois migrar as tabelas:

php artisan migrate

Caso ocorra erro na migração sobre quantidade de caracteres das tabelas do banco de dados deve ser colocada uma
linha de código em app – providers – appServiceProvider.php

Caso não apareça toda a formatação das caixas de login/registro rodar os comandos abaixo para corrigir:
npm install
npm run dev
Depois iniciar a instalação do pacote:
On the root folder of your Laravel project, require the package using composer:

composer require jeroennoten/laravel-adminlte

php artisan adminlte:install

Para checar se foi instalado o pacote:

php artisan adminlte:status

Publicar a aplicação:
php artisan vendor:publish --provider="JeroenNoten\LaravelAdminLte\AdminLteServiceProvider" --tag=views

ou

php artisan vendor:publish --provider="JeroenNoten\LaravelAdminLte\AdminLteServiceProvider" --tag=config

Depois limpar as configurações:

php artisan config:clear

php artisan cache:clear

Atualizar e carregar as classes do pacote:

composer dump-autoload

Atualizar o pacote:

composer update jeroennoten/laravel-adminlte

php artisan adminlte:update

Publicar as alterações:

php artisan adminlte:install --only=main_views –force

Caso queira utilizar o modelo de autenticação do adminlte terá que realizar a troca do modelo original utilizando:

Até laravel 5.9:

php artisan make:adminlte

A partir de 6.0:

This package provides the following command to replace the Laravel default authentication views (those inside the
folder resources/views/auth) with a set of AdminLTE styled views.

php artisan adminlte:install --only=auth_views

Finalizando com a alteração do nome do pacote para adminlte::page na página home.blade.php

To use the blade template provided by this package, just create a new blade file and extend the layout
with @extends('adminlte::page').
CRIAÇÃO DE CRUD LARAVEL 7

1. Instalar o laravel 7:
composer create-project laravel/laravel example-app

2. Criar BD da aplicação e colocar o nome, usuário e senha do BD no arquivo .env.

3. Para facilitar a criação das tabelas dentro do BD podemos usar as migrações que são modelos de como criar
uma tabela que contém todas as informações para a criação da tabela propriamente dita.

Php artisan make:model Livro -m

No comando acima, por convenção, temos que usar o nome do modelo com a primeira letra maiúscula. Será
criado então, um arquivo de modelo e de migração de tabela onde o nome da tabela será composto pelo nome
dado anteriormente no primeiro comando Ex. model Livro acrescido da letra “s”.

Após isso dentro de database – migrations estará criado o arquivo

data_da_criacao_create_nome_da_tabela_com_s_table.php e dentro desse arquivo temos um código básico
para a criação da tabela “Livros” onde id é a chave primária e timestamps é um campo específico para guardar a
data de qualquer alteração na tabela, a partir daí é só acrescentar os outros campos específicos.
Após incluir os campos específicos no código temos que rodar o comando abaixo para que o laravel crie
automaticamente as tabelas necessárias dentro do BD da aplicação:

php artisan migrate

No BD serão criadas as tabelas necessárias para a aplicação:

Agora devemos abrir o model Livro.php e incluir no seu código quais os campos que terão seus dados manipulados
no crud:

Podemos, então, ir em resources – views, criar uma pasta para ficar mais organizado os arquivos e criar o arquivo
para a visualização dos dados:

Dentro do arquivo criado create.blade.php você deve inserir o código da página que será visualizada pelos usuários.
Devemos sempre usar o @csrf dentro do formulário que irá criar um token CSRF para proteger a aplicação contra
ataques.

Depois devemos criar um arquivo controller onde deve ficar as definições das ações da aplicação:

php artisan make:controller LivrosController

A função acima ao ser acionada irá retornar a view que está dentro da pasta livros com o nome de create, não
necessitando colocar o restante da extensão .blade.php.

Agora dentro de routes – web.php devemos criar a rota ou link que o usuário irá acessar a aplicação pelo navegador:

A primeira parte é o endereço que o usuário irá digitar para acessar a aplicação: /Livro/novo

Na segunda parte colocamos qual o controller e a sua função interna que a aplicação irá acessar:
LivrosController@create.

Já a função interna create() que está dentro de LivrosController irá retornar a view create.blade.php.
Em seguida devemos criar a função de armazenagem post, que será chamada store, dentro de LivrosController.php,
mas, Primeiro temos que chamar o model que tem os nomes dos campos para salvar (Livros::create):

Criaremos agora uma nova rota para a função store dentro de web.php:
Como estamos usando post o endereço /Livro/novo pode ser o mesmo e podemos dar um nome especial para essa
rota (salvar_livro).

Dentro de create.blade.php devemos alterar o código do formulário para incluir o caminho da rota para utilizar a
função store:

Quando o usuário acessar a página de inclusão e incluir os dados novos deverá aparecer uma msg:
Para criar um código que irá preencher com valores aleatórios uma tabela no BD podemos utilizar o comando:

php artisan make:seeder nome_da_tabelaTableSeeder

Um seeder é uma classe especial utilizada para gerar e inserir dados de amostra (seeds) em um banco de dados. Essa
é uma característica importante em ambientes de desenvolvimento, uma vez que permite que você recrie o
aplicativo com um banco de dados novo, usando valores de amostra que, de qualquer forma você teria que inserir
manualmente toda vez que o banco de dados fosse recriado.

Após isso será criado um arquivo chamado nome_escolhidoTableSeeder.php. Agora devemos editar o arquivo e
incluir o código para popular o BD.

Podemos, também, criar um Factory para auxiliar na inserção de dados:

php artisan make:factory nome_escolhidoFactory

A Factory é usado no momento de desenvolvimento/teste de software. Sabe quando você está programando sua
aplicação e precisa ver como ele se comporta com múltiplos registros?

A Factory vai permitir o programador inserir múltiplos registros “aleatórios” dentro do Banco de Dados, se você
quiser 50 registros, 100 ou 1000, será só especificar a quantidade.

Esses registros não serão completamente aleatórios, o Factory no Laravel nos permite setar um ‘escopo’ para o tipo
de dado a inserir em determinado tipo de campo, de forma que podemos ter nomes aleatórios para campos de
nomes, e-mails aleatórios e únicos para campos de email, ou seja, apesar de randômicos, os registros seguirão um
certo escopo para que não sejam inseridos dados inválidos (como um e-mail em um campo de endereço, por
exemplo).
Este exemplo preenche o campo title da tabela Posts com 4 palavras aleatórias.

Este exemplo preenche o campo image da tabela PostImages com endereçamentos de imagens aleatórias do site
http://lorempixel/640/480.

Após editar o código dentro da factory devemos editar o seeder e criar o código que irá acionar as nossas factory.
Devemos, ainda, editar o DatabaseSeeder.php para chamar o seeder que foi criado.

Depois de todos esses procedimentos podemos acionar o seeder para popular o BD:

php artisan db:seed

Caso ocorra algum erro no após rodar esse comando, devemos corrigir esse erro e utilizar o comando abaixo para
refazer todas as migrations, atualizar toda aplicação e acionar de novo o seeder:

php artisan migrate:refresh --seed

As tabelas ficarão conforme abaixo: