Artigos - Artigos e dicas feito com PHP + Laravel

Posted on: November 13, 2020 12:16 AM

Posted by: Renato

Categories: Laravel PHP

Views: 534

PHP Laravel migration

"Understand Laravel Migration using a PHP Application"

Entenda a Migration do Laravel usando um aplicativo PHP

"

Without a doubt, Laravel is the best PHP framework right now. It would be nice if all PHP applications are migrated to Laravel, though this is wishful thinking. However, if you are here then you must be interested in doing that. This article is going to explain how Laravel migration works

Our case study will be a Todo list app built in vanilla PHP. We are using a to-do application because a to-do’s are a good way to demonstrate CRUD (Create Read Update and Delete).

Here is a preview of our case study:"

Sem dúvida, o Laravel é o melhor framework PHP da atualidade. Seria bom se todos os aplicativos PHP fossem migrados para o Laravel, embora isso seja uma ilusão. No entanto, se você está aqui, então deve estar interessado em fazer isso. Este artigo vai explicar como funciona a migração do Laravel. Nosso estudo de caso será um aplicativo de lista de tarefas feito em PHP vanilla. Estamos usando um aplicativo de tarefas porque as tarefas são uma boa maneira de demonstrar CRUD (Criar, Ler, Atualizar e Excluir). Aqui está uma prévia do nosso estudo de caso:

Para acompanhar este tutorial, você precisa ter um conhecimento prático de PHP e do framework Laravel.

Laravel framework.laravel

• Migrating databases
• Data querying
• Authentication
• MVC
• Routing
• Security

Começando com nossas tabelas de banco de dados, normalmente escreveríamos consultas SQL para criar ou modificar uma tabela, mas no Laravel, usaremos migrações.

Uma migração é uma maneira elegante de especificar a estrutura da tabela sem se preocupar em escrever um monte de consultas SQL. Ainda mais, as migrações funcionam um pouco como o Git, pois permite fazer alterações incrementais, reverter alterações e também manter a estrutura do banco de dados em sincronia quando várias equipes estão trabalhando no mesmo aplicativo.

Aqui está um exemplo de consulta SQL que você teria que escrever manualmente ao criar o aplicativo Todo usando o vanilla PHP:

CREATE TABLE `tasks` (
      `id` int(11) NOT NULL,
      `user_id` varchar(100) NOT NULL,
      `title` text NOT NULL,
      `completed` tinyint(1) NOT NULL,
      `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

No Laravel, no entanto, em vez de criar e executar esta consulta SQL manualmente, criaremos uma nova migration do Laravel usando a ferramenta CLI artesanal que vem com o Laravel:

    $ php artisan make:migration create_tasks_table --create="tasks"

Quando o comando for executado, você obterá um novo arquivo de migration em sua pasta: database/migrations

 increments('id');
                $table->timestamps();
            });
        }

        /**
         * Reverse the migrations.
         *
         * @return void
         */
        public function down()
        {
            Schema::dropIfExists('tasks');
        }
    }

There are two methods up() and down(). up() is always associated with making new tables or fields in the database. The down() method is there to undo, or rollback, whatever the up() method does.

Uma única tabela pode ter muitos arquivos de migração que são executados cronologicamente para torná-la o que você quiser. Contanto que você implemente o método para up e para down corretamente, você estará bem. Com isso dito, vamos modificar nossa migration para coincidir com a consulta SQL que escrevemos anteriormente.

    [...]

    public function up() {
        Schema::create('tasks', function (Blueprint $table) {
            $table->increments('id');
            $table->integer('user_id')->nullable();
            $table->string('title')->nullable();
            $table->tinyInteger('completed')->nullable();
            $table->timestamps();
        });
    }

    public function down() {
        Schema::dropIfExists('tasks');
    }

    [...]

Como visto acima, as migration são uma maneira mais fácil de gerenciar a estruturação do banco de dados do que manualmente. Para executar suas migrações pendentes, execute o comando abaixo:

    $ php artisan migrate

To learn more about migrations use the official Laravel documentation.

Os dados são vitais para a maioria dos aplicativos e a maneira como os dados estão sendo manipulados deve ser levada em consideração. Para buscar todas as tarefas de um usuário conectado, teríamos que usar algo como pdo para preparar nossa declaração.

$user = $_SESSION['user_id'];
    $query = $pdo->prepare('SELECT * FROM todos WHERE user_id=? ORDER BY id DESC');
    $query->execute([$user]);

Enquanto você está seguro contra a injeção de SQL, ainda precisa validar e higienizar seus dados inseridos pelo usuário. Você pode usar uma função como filter_var() para validar antes de inseri-lo no banco de dados e htmlspecialchars() para limpar após recuperá-lo.

Laravel entretanto, usa um ORM (Mapeamento Objeto Relacional) chamado Eloquent. O Eloquent torna mais fácil trabalhar com bancos de dados para fazer coisas como acessar os registros, excluir registros e muito mais. O modelo Eloquent funciona convertendo automaticamente as colunas da tabela em propriedades de classe PHP. O Eloquent torna as tarefas de adicionar, excluir e atualizar o banco de dados fáceis e sem a necessidade de escrever consultas complexas.

Aqui está a mesma consulta acima escrita no Eloquent:

    $tasks = Task::whereUserId(Auth::id())->get();

Como você pode ver, reduzimos o código escrito a uma linha usando o Eloquent.

? Para ver a consulta SQL gerada pelo Eloquent, você pode substituir get() por toSql() e despejar a string resultante.

"? To see the SQL query generated by Eloquent, you can replace get() with toSql() and dump the resulting string."

Laravel-Eloquent

Authentication - Autenticação

A autenticação é outra parte crítica da maioria dos aplicativos. O Laravel facilita a configuração de um sistema de autenticação completo com um comando.

In your Laravel project run the command:

    $ php artisan make:auth

Este comando economizará horas de trabalho em comparação com escrever tudo do zero usando o vanilla PHP.

Em um aplicativo PHP vanilla, você precisa escrever consultas para armazenar as informações do usuário registrado no banco de dados e, em seguida, buscar e verificar se existe um usuário com as credenciais fornecidas quando o usuário está tentando fazer login.

Vai parecer algo assim:

prepare('SELECT * FROM users WHERE email = ? AND password=?');
        $query->execute([$email, $pass]);
        $rows = $query->rowCount();

        if( $rows > 0 ) {
            $_SESSION['user_id'] = $email;

            header('location: pages/home.php');
        } else {
            echo 'Invalid Credentials`;
        }
    }

O código acima simula um login básico usando vanilla PHP e, como de costume, você deve escrever suas próprias consultas, gerenciar suas sessões, lidar com a conexão com o banco de dados. É cansativo.

    $ php artisan make:auth

Isso irá gerar um scaffold de autenticação com visualizações e rotas para você.

As visualizações geradas são para login e registro junto com a senha esquecida, que pode ser encontrada na pasta resources/views/auth.

Os controladores para login, registro e redefinição de senha podem ser encontrados na pasta app/Http/Controllers/Auth.

Vamos dar uma olhada no controlador de registro do Laravel:

 // [...]

    protected $redirectTo = '/home';

    public function __construct()
    {
        $this->middleware('guest');
    }

    protected function validator(array $data)
    {
        return Validator::make($data, [
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|min:6|confirmed',
        ]);
    }

    public function create(array $data)
    {

        return User::create([
            'name' => $data['name'],
            'email' => $data['email'],
            'password' => Hash::make($data['password']),
        ]);
    }

    //  [...]

A variável protegida $redirectTo contém a URL para a qual seu aplicativo redirecionará após um registro bem-sucedido. O construtor especifica o middleware que seu registro deve ser executado antes de continuar para o controlador.

Middlewares fornecem um mecanismo conveniente para filtrar solicitações HTTP que entram em seu aplicativo.

O Laravel inclui um middleware que verifica se o usuário do seu aplicativo está autenticado. Se o usuário não estiver autenticado, o middleware redirecionará o usuário para a tela de login. No entanto, se o usuário for autenticado, o middleware permitirá que a solicitação prossiga no aplicativo.

Neste caso, $this->middleware('guest'); ('convidado') permite que usuários que não estão logados ou autenticados acessem a página de registro, você pode ler mais sobre middlewares aqui. middleware

A função validator() valida cada campo dos dados de registro de entrada. Por exemplo, 'name' => 'required|string|max:255' valida que o campo do name não está vazio, é uma string e não excede 255 caracteres. validation

Finalmente, a função create() usa o modelo User para armazenar os dados validados no banco de dados.

A Hash facade fornece hashing bcrypt and argon2 seguro para armazenar senhas de usuário User. Bcrypt será usado para registro e autenticação por padrão. Você pode aprender mais sobre hashing aqui e pode ler mais sobre o Auth do Laravel aqui. Bcrypt será usado para registro e autenticação por padrão.

MVC é um acrônimo para Model View Controller, é uma maneira de separar a lógica do seu aplicativo e o modelo de dados da visualização. Isso ajuda a tornar nossa organização de código limpa e melhora nosso tempo de desenvolvimento de aplicativos.

Ao desenvolver aplicativos PHP vanilla, é provável que você tenha que descobrir como deseja organizar seu aplicativo.

Com o Laravel tudo foi organizado para que seja mais fácil encontrar o que você procura. Ele também foi organizado para tornar mais fácil seguir princípios de codificação como o SOLID.

Model

O modelo é simplesmente o objeto que faz a interface entre o armazenamento de dados e seu controlador. Em nosso aplicativo, usamos o modelo Task para buscar dados do banco de dados usando o Eloquent.

View

A visão é o que é apresentado aos usuários. É assim que os usuários interagem com nosso aplicativo, a partir dos botões, campos de texto e assim por diante. A visualização é composta principalmente de HTML e CSS.

No Laravel, as visualizações são modelos de lâmina. Blade é um mecanismo de modelagem incrível que torna mais fácil trabalhar com variáveis ​​passadas para a visualização.

The views are stored in the resources/views directory.

@extends('layouts.app')

    @section('content')
    <div class="container">
        <div class="row justify-content-center">
            <div class="col-md-8">
                <div class="card">
                    <div class="card-header">Add a task</div>

                    <div class="card-body">
                        @if (session('status'))
                            <div class="alert alert-success" role="alert">
                                {{ session('status') }}
                            </div>
                        @endif
                        <form method="post" action="/task/add">
                          @csrf
                          <input type="text" name="title" required/>
                          <button type="submit" class="btn-primary">add task</button>
                        </form>
                    </div>

                    @foreach ($tasks as $task)
                      @if ($task['completed'] == 1)
                        <div class="card-body">
                          <strike>{{$task['title']}}</strike> <button class="btn-warning" disabled>completed</button>
                        </div>
                      @else
                      <div class="card-body">
                        {{$task['title']}} <a href="/task/delete/{{$task['id']}}"><button class="btn-danger">delete task</button></a> <a href="/task/complete/{{$task['id']}}"><button class="btn-success">Mark as completed</button></a>
                      </div>
                      @endif
                    @endforeach
                </div>
            </div>
        </div>
    </div>
    @endsection

Controller

O controlador é o tomador de decisão e o intermediário entre o modelo e a visualização. O controlador carrega e passa dados para a visualização na maioria das vezes a partir do modelo. Ele também adiciona ouvintes de eventos à visualização e atualiza o modelo quando o usuário manipula a visualização (view).

Here is our TaskController:

 middleware('auth');
        }

        /**
         * Show the application dashboard.
         *
         * @return IlluminateHttpResponse
         */
        public function index()
        {
            $tasks = Task::whereUserId(Auth::id())->get();

            return view('home', compact('tasks'));
        }

        public function create (Request $request) 
        {
          $task = Task::create([
            'user_id' => Auth::id(),
            'title' => $request->get('title'),
            'completed' => 0,
          ]);

          return redirect('/tasks');
        }

        public function completed ($id) 
        {
          $task = Task::find($id);
          $task->completed = 1;
          $task->save();

          return redirect('/tasks');
        }

        public function delete ($id) 
        {
          $task = Task::find($id);
          $task->delete();

          return redirect('/tasks');
        }
    }

Routing

O roteamento ajuda a mapear caminhos de URL para várias partes de nosso aplicativo. No vanilla PHP, pode ser assim que você escolheria lidar com o roteamento:

O Laravel, no entanto, tem um sistema de roteamento bacana que o torna mais fácil sem ter que construir um novo roteador do zero. O arquivo de rotas está no arquivo routes/web.php:

 Route::get('/', function () {
        return view('welcome');
    });

    Auth::routes();

    Route::get('/tasks', 'TaskController@index')->name('home');

    Route::post('/task/add', 'TaskController@create');

    Route::get('/task/delete/{id}', 'TaskController@delete');

    Route::get('/task/complete/{id}', 'TaskController@completed');

Security

O Laravel fornece um monte de recursos de segurança que a maioria dos desenvolvedores pode não levar em consideração ao construir aplicações web.

CSRF (Cross Site Request Forgery)

CSRF é quando um usuário autenticado é induzido a fazer solicitações válidas em nome de um hacker malicioso. Não é de forma alguma um ataque trivial e pode se tornar muito complicado e expor todo o seu aplicativo a ataques de vários graus.

https://github.com/neoighodaro-articles/todolist-demo

https://blog.pusher.com/php-laravel-migration/

Renato

Developer

No comments yet! Be the first to comment