Usuários e Controle de Acesso no Laravel

Oscar Dias 18 de julho de 2014 36 Comentários

Continuando nossa série sobre o Laravel, vou escrever sobre usuários, segurança e controle de acesso (autenticação e sessões). Diferentemente do que fiz nos últimos artigos, não vou fazer uma referência teórica do assunto. Vamos direto para as alterações. Boa parte do que será feito já foi visto, então vou explicar em detalhes apenas o que for novidade.

Se você não acompanhou os artigos anteriores pode baixar o aplicativo que vamos utilizar neste link. Nós vamos começar com a criação de uma nova tabela no banco de dados. Depois vamos para o controle de acesso.

Antes de começarmos as modificações deste artigo, execute um composer update para atualizar as dependências. Estamos trabalhando com o Laravel 4.1 e a versão mais atual é a 4.1.30. Já está disponível a versão 4.2, mas vou deixar esta atualização para outro artigo.

Contas de Usuário

Para criarmos o controle de acesso no nosso aplicativo, precisamos ter usuários cadastrados no sistema. Vamos começar com o banco de dados.

Banco de Dados

Vamos criar uma tabela chamada usuários. Para isso vamos utilizar as migrações do Laravel (veja mais aqui). Abra o terminal e execute o seguinte comando:

php artisan migrate:make criar_usuario

1	php artisan migrate:make criar_usuario

Abra o arquivo criado (que estará em app/database/migrations) e coloque o seguinte conteúdo:

<?php

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CriarUsuario extends Migration {

    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('usuarios', function($table)
        {
            $table->increments('id');
            $table->string('email', 255)->unique();
            $table->string('senha', 60);
            $table->string('nome', 255);
            $table->enum('tipo', array('admin', 'autor'));
            $table->string('remember_token', 100)->nullable();
            $table->timestamps();
        });
    }

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

}

<?php

use Illuminate\Database\Schema\Blueprint;

use Illuminate\Database\Migrations\Migration;

class CriarUsuario extends Migration {

/**

* Run the migrations.

* @return void

public function up()

{

Schema::create('usuarios', function($table)

{

$table->increments('id');

$table->string('email', 255)->unique();

$table->string('senha', 60);

$table->string('nome', 255);

$table->enum('tipo', array('admin', 'autor'));

$table->string('remember_token', 100)->nullable();

$table->timestamps();

});

}

/**

* Reverse the migrations.

* @return void

public function down()

{

Schema::drop('usuarios');

}

Vamos criar campos para email, senha, email e nome. Além disso temos um campo tipo, que usaremos para diferenciar usuários administradores (com acesso ao cadastro de usuários) e autores. Por fim também temos um campo remember_token, que é usado pelo Laravel para enviar lembretes de senha permitindo aos usuários reiniciar suas senhas.

Para conseguirmos enviar o lembrete de senhas também precisamos de uma tabela para guardar os tokens. para criar a migração que vai criar esta tabela execute o comando:

php artisan auth:reminders-table

1	php artisan auth:reminders-table

O Laravel vai criar a migração já com o conteúdo preenchido, portanto não é necessário nenhuma modificação. Vamos executar as migrações executando:

php artisan migrate

1	php artisan migrate

Model

Precisamos também criar um model para a tabela de usuário. Na instalação padrão do Laravel já existe um model chamado User.php, para ser utilizado. Para manter a lógica da nossa aplicação em português, eu preferi chamar a tabela de usuarios ao invés de user, além de usar senha no lugar de password. Por isso vamos customizar esse model. Primeiro renomeie ele para Usuario.php.

<?php

use Illuminate\Auth\UserInterface;
use Illuminate\Auth\Reminders\RemindableInterface;

class Usuario extends Eloquent implements UserInterface, RemindableInterface {

	/**
	 * The database table used by the model.
	 *
	 * @var string
	 */
	protected $table = 'usuarios';

	/**
	 * The attributes excluded from the model's JSON form.
	 *
	 * @var array
	 */
	protected $hidden = array('senha');

	/**
	 * Get the unique identifier for the user.
	 *
	 * @return mixed
	 */
	public function getAuthIdentifier()
	{
		return $this->getKey();
	}

	/**
	 * Get the password for the user.
	 *
	 * @return string
	 */
	public function getAuthPassword()
	{
		return $this->senha;
	}

	/**
	 * Get the e-mail address where password reminders are sent.
	 *
	 * @return string
	 */
	public function getReminderEmail()
	{
		return $this->email;
	}
        
	/**
	 * Get the token value for the "remember me" session.
	 *
	 * @return string
	 */
        public function getRememberToken()
        {
            return $this->remember_token;
        }

	/**
	 * Set the token value for the "remember me" session.
	 *
	 * @param  string  $value
	 * @return void
	 */
        public function setRememberToken($value)
        {
            $this->remember_token = $value;
        }

	/**
	 * Get the column name for the "remember me" token.
	 *
	 * @return string
	 */
        public function getRememberTokenName()
        {
            return 'remember_token';
        }

}

<?php

use Illuminate\Auth\UserInterface;

use Illuminate\Auth\Reminders\RemindableInterface;

class Usuario extends Eloquent implements UserInterface, RemindableInterface {

/**

* The database table used by the model.

* @var string

protected $table = 'usuarios';

/**

* The attributes excluded from the model's JSON form.

* @var array

protected $hidden = array('senha');

/**

* Get the unique identifier for the user.

* @return mixed

public function getAuthIdentifier()

{

return $this->getKey();

}

/**

* Get the password for the user.

* @return string

public function getAuthPassword()

{

return $this->senha;

}

/**

* Get the e-mail address where password reminders are sent.

* @return string

public function getReminderEmail()

{

return $this->email;

}

/**

* Get the token value for the "remember me" session.

* @return string

public function getRememberToken()

{

return $this->remember_token;

}

/**

* Set the token value for the "remember me" session.

* @param string $value

* @return void

public function setRememberToken($value)

{

$this->remember_token = $value;

}

/**

* Get the column name for the "remember me" token.

* @return string

public function getRememberTokenName()

{

return 'remember_token';

}

Neste model temos a implementação das interfaces UserInterface e RemindableInterface. Como nós alteramos o nome do model padrão para autenticação, precisamos alterar o arquivo de configuração app/config/auth.php.

	/*
	|--------------------------------------------------------------------------
	| Authentication Model
	|--------------------------------------------------------------------------
	|
	| When using the "Eloquent" authentication driver, we need to know which
	| Eloquent model should be used to retrieve your users. Of course, it
	| is often just the "User" model but you may use whatever you like.
	|
	*/

	'model' => 'Usuario',

|--------------------------------------------------------------------------

| Authentication Model

|--------------------------------------------------------------------------

| When using the "Eloquent" authentication driver, we need to know which

| Eloquent model should be used to retrieve your users. Of course, it

| is often just the "User" model but you may use whatever you like.

'model' => 'Usuario',

Altere apenas a chave model para identificar o nosso novo model.

Controle de Acesso

Database Seeding

Agora que temos a tabela criada, vamos inserir alguns dados nessa tabela. Precisamos que pelo menos um usuário seja criado automaticamente, porque depois que finalizamos o controle de acesso precisamos fazer login para alterar os usuários. Ou seja, se você instalar esse código em um novo computador, não conseguirá criar nenhum usuário. Isso é chamado de database seeding, algo como semear o banco de dados. Abra o arquivo app/database/seeds/DatabaseSeeder.php.

<?php

class DatabaseSeeder extends Seeder {

     /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        Eloquent::unguard();

        $this->call('TabelaUsuarioSeeder');
    }

}

class TabelaUsuarioSeeder extends Seeder {

    public function run()
    {
        $usuarios = Usuario::get();

        if($usuarios->count() == 0) {
            Usuario::create(array(
                'email' => 'seu@email.com',
                'senha' => Hash::make('admin'),
                'nome'  => 'Seu Nome',
                'tipo'  => 'admin'
            ));
        }
    }

}

<?php

class DatabaseSeeder extends Seeder {

/**

* Run the database seeds.

* @return void

public function run()

{

Eloquent::unguard();

$this->call('TabelaUsuarioSeeder');

}

class TabelaUsuarioSeeder extends Seeder {

public function run()

{

$usuarios = Usuario::get();

if($usuarios->count() == 0) {

Usuario::create(array(

'email' => 'seu@email.com',

'senha' => Hash::make('admin'),

'nome' => 'Seu Nome',

'tipo' => 'admin'

));

}

Esse código vai inserir um usuário somente quando não houver nenhum usuário no banco de dados. Nesse código você pode ver o método Hash::make(). Este método vai gerar um hash da string passada por parâmetro. Desta maneira você guarda apenas este hash e não expõe as senhas dos seus usuários. Para executar esse seed, execute o comando:

php artisan db:seed

1	php artisan db:seed

Agora que temos um usuário na nossa base de dados, vamos criar uma tela de login e fazer o controle de acesso.

Autenticação

A primeira coisa que precisamos para autenticar usuários é criar as rotas para isso. Como já existe um HomeController na nossa aplicação, vamos usar ele para fazer o login e logout do usuário. Também vamos bloquear o acesso para usuários não autenticados ao nosso controller de artigos. O visitante vai ver os artigos diretamente na raiz.

// Validação CSRF
Route::when('*', 'csrf', array('post'));

// Visitante
Route::get('/',
        array(
            'as' => 'home', 
            'uses' => 'HomeController@getIndex'
            )
        );

Route::get('entrar', 'HomeController@getEntrar');
Route::post('entrar', 'HomeController@postEntrar');
Route::get('sair', 'HomeController@getSair');

// Verifica se o usuário está logado
Route::group(array('before' => 'auth'), function()
{
    // Rota de artigos
    Route::controller('artigos', 'ArtigosController');
});

// Validação CSRF

Route::when('*', 'csrf', array('post'));

// Visitante

Route::get('/',

array(

'as' => 'home',

'uses' => 'HomeController@getIndex'

)

);

Route::get('entrar', 'HomeController@getEntrar');

Route::post('entrar', 'HomeController@postEntrar');

Route::get('sair', 'HomeController@getSair');

// Verifica se o usuário está logado

Route::group(array('before' => 'auth'), function()

{

// Rota de artigos

Route::controller('artigos', 'ArtigosController');

});

A verificação de autenticação usa um filtro chamado auth. Esse filtro já existe no arquivo app/filters.php. Ele verifica se o usuário é visitante e encaminha o usuário para login. Como eu utilizei na rota o caminho entrar, temos que alterar o filtro também.

Route::filter('auth', function()
{
	if (Auth::guest()) return Redirect::guest('entrar');
});

Route::filter('auth', function()

{

if (Auth::guest()) return Redirect::guest('entrar');

});

O próximo passo é implementar o HomeController. Neste controller teremos dois métodos para entrar na nossa aplicação – getEntrar e postEntrar – e um método para encerrar a sessão – getSair. Vamos ver como fica o código:

<?php

class HomeController extends BaseController {

    public function getIndex()
    {
        return View::make('hello');
    }

    public function getEntrar()
    {
        $titulo = 'Entrar - Desenvolvendo com Laravel';
        return View::make('home/entrar', compact('titulo'));
    }

    public function postEntrar()
    {
        // Opção de lembrar do usuário
        $remember = false;
        if(Input::get('remember'))
        {
            $remember = true;
        }
        
        // Autenticação
        if (Auth::attempt(array(
            'email' => Input::get('email'), 
            'password' => Input::get('senha')
            ), $remember))
        {
            return Redirect::to('artigos');
        }
        else
        {
            return Redirect::to('entrar')
                ->with('flash_error', 1)
                ->withInput();
        }
    }
    
    public function getSair()
    {
        Auth::logout();
        return Redirect::to('/');
    }
}

<?php

class HomeController extends BaseController {

public function getIndex()

{

return View::make('hello');

}

public function getEntrar()

{

$titulo = 'Entrar - Desenvolvendo com Laravel';

return View::make('home/entrar', compact('titulo'));

}

public function postEntrar()

{

// Opção de lembrar do usuário

$remember = false;

if(Input::get('remember'))

{

$remember = true;

}

// Autenticação

if (Auth::attempt(array(

'email' => Input::get('email'),

'password' => Input::get('senha')

), $remember))

{

return Redirect::to('artigos');

}

else

{

return Redirect::to('entrar')

->with('flash_error', 1)

->withInput();

}

public function getSair()

{

Auth::logout();

return Redirect::to('/');

}

A parte mais importante aqui é o postEntrar. Para executar a autenticação propriamente dita usamos o seguinte método: Auth::attempt(). O primeiro parâmetro é um array com a credenciais do usuário – independentemente do nome que você der para o campo senha, ele deve ser passado como password sempre. O segundo parâmetro serve para indicar se devemos lembrar do usuário ou não para a próxima sessão.

Para finalizar, precisamos de uma view para a tela de login. Crie o arquivo app/views/home/entrar.blade.php e coloque o seguinte conteúdo:

@extends('layouts.padrao')

@section('content')
<div class="row">
    <div class="col-sm-offset-3 col-sm-6">
        {{ Form::open(array(
            'url' => 'entrar',
            'class'  => 'well'
        )) }}
            
            <div class="form-group">
                {{ Form::email('email', '', array('class' => 'form-control input-lg', 'autofocus', 'placeholder' => 'E-mail')) }}
            </div>
            
            <div class="form-group">
                {{ Form::password('senha', array('class' => 'form-control input-lg', 'placeholder' => 'Senha')) }}
            </div>
            
            @if (Session::has('flash_error'))
                <div class="alert alert-danger">E-mail ou senha inválidos.</div>
            @endif
            
            <label class="checkbox">
                {{ Form::checkbox('remember', 'remember', true) }} Lembre-se de mim
            </label>
            
            {{ Form::submit('Entrar', array('class' => 'btn btn-lg btn-primary btn-block')) }}

        {{ Form::close() }}
    </div>
</div>
@stop

@extends('layouts.padrao')

@section('content')

{{ Form::open(array(

'url' => 'entrar',

'class' => 'well'

)) }}

{{ Form::email('email', '', array('class' => 'form-control input-lg', 'autofocus', 'placeholder' => 'E-mail')) }}

</div>

{{ Form::password('senha', array('class' => 'form-control input-lg', 'placeholder' => 'Senha')) }}

</div>

@if (Session::has('flash_error'))

<div class="alert alert-danger">E-mail ou senha inválidos.</div>

@endif

{{ Form::checkbox('remember', 'remember', true) }} Lembre-se de mim

</label>

{{ Form::submit('Entrar', array('class' => 'btn btn-lg btn-primary btn-block')) }}

</div>

@stop

Ao acessar o endereço http://<dominio>/entrar essa é a tela que você verá:

Se você acessar o endereço http://<dominio>/artigos sem uma sessão autenticada, você será redirecionado para a tela de login. A última alteração que precisamos é alterar nosso menu para incluir o link para o login (quando o usuário não está autenticado) e para o logout. Abra o arquivo menu.blade.php e acrescente esse código no final da DIV #bs-example-navbar-collapse-1 (com ID = bs-example-navbar-collapse-1).

@if(Auth::check())
<a href="{{ url('sair') }}" class="btn btn-danger navbar-btn navbar-right">Sair</a>
@else
<a href="{{ url('entrar') }}" class="btn btn-success navbar-btn navbar-right">Entrar</a>
@endif

@if(Auth::check())

@else

<a href="{{ url('entrar') }}" class="btn btn-success navbar-btn navbar-right">Entrar</a>

@endif

Bonus – Cadastro de Usuários

Como já falamos sobre como inserir dados no banco, não vou explicar como criar um cadastro para os usuários. Mas a implementação já está feita e disponível no Github. Para baixar o aplicativo clique aqui.

A parte importante é a segurança do nosso cadastro de usuários. Não queremos que ninguém além dos administradores acesse o cadastro de usuários. Para isso vamos acrescentar um novo grupo de rotas dentro da nossa verificação de autenticação:

// Verifica se o usuário está logado
Route::group(array('before' => 'auth'), function()
{
    // Rota de artigos
    Route::controller('artigos', 'ArtigosController');
    
    // Rotas do administrador
    Route::group(array('before' => 'auth.admin'), function()
    {
        Route::controller('usuarios', 'UsuariosController');
    });
});

// Verifica se o usuário está logado

Route::group(array('before' => 'auth'), function()

{

// Rota de artigos

Route::controller('artigos', 'ArtigosController');

// Rotas do administrador

Route::group(array('before' => 'auth.admin'), function()

{

Route::controller('usuarios', 'UsuariosController');

});

Neste novo grupo usamos um filtro chamado auth.admin. Ele será responsável por validar se o usuário logado é admin ou não.

Route::filter('auth.admin', function()
{
    $usuario = Auth::user();
    if($usuario->tipo !== 'admin')
    {
        return Redirect::home();
    }
});

Route::filter('auth.admin', function()

{

$usuario = Auth::user();

if($usuario->tipo !== 'admin')

{

return Redirect::home();

}

});

Conclusão

O controle de acesso no Laravel é bem simples de ser implementado. O framework já possui diversas funcionalidades para acelerar a construção do controle de usuários no sistema. Eu fiz diversas alterações aqui apenas para mostrar que são possíveis. Mas eu recomendo que você siga o padrão o máximo possível – utilizando o model User, o nome da tabela users e o campo password na sua tabela. Isso minimiza as customizações e reduz o trabalho.

Com este artigo finalizamos todos os itens mais genéricos do Laravel. A partir de agora vou começar uma sequencia de artigos mais menores e mais específicos. No próximo vou escrever um pouco mais sobre o Eloquent, dessa vez vou focar no relacionamento entre tabelas.

Este post é parte da série Desenvolvendo com Laravel.

Introdução ao Laravel
Iniciando um Novo Projeto no Laravel
Banco de Dados no Laravel
Laravel: Rotas e Controllers
Templates com Blade e Bootstrap no Laravel
Usuários e Controle de Acesso no Laravel
Relacionamento entre Tabelas no Laravel

Sobre Oscar Dias

Sou formado em Ciência da Computação pela UFRGS, possuo MBA em Gerenciamento de Projetos e Master of IT Management pela University of Sydney. Tenho experiência em diversas tecnologias, como PHP, ABAP, C#, etc. Atualmente meu foco é a Softerize Sistemas (minha empresa) e a criação de sistemas utilizando PHP e Laravel.

Mídias sociais:

36 respostas para “Usuários e Controle de Acesso no Laravel”

Carlos disse:

5 de agosto de 2014 às 18:09

Olá Oscar Dias,

Muito boa sua série de tutoriais, me ajudou bastante, espero que continue postando. 🙂

Tenho uma dúvida, quando eu for hospedar minha aplicação desenvolvida no Laravel em um servidor tipo hostgator, locaweb, etc, como faço para que a pasta public seja a referência, ou seja, tudo comece por ela?

Outra pergunta, preciso de desenvolver um sistema grande, você recomenda que eu utilize o Laravel?

Além da documentação oficial, onde mais você recomenda eu estudar?

Um abraço amigo.

Responder
1. Oscar Dias disse:
  
  6 de agosto de 2014 às 12:50
  Olá Carlos,
  
  Obrigado por acompanhar. As vezes eu não consigo escrever com a frequência que gostaria, mas ainda tem muito assunto para escrever, então vou continuar sim.
  
  Para hospedar em um servidor compartilhado eu recomendo que você crie uma pasta fora do www para colocar o Laravel e copie o conteúdo da pasta public dentro do www. Ficaria assim:
  /laravel
  - /app
  - /bootstrap
  - /vendor
  - …
  /www
  - /packages
  - .htaccess
  - index.php
  Depois você precisa atualizar o arquivo bootstrap/paths.php:
  // Modifique isso 'public' => __DIR__.'/../public',
  // Para isso 'public' => __DIR__.'/../../www',
  
  Depois precisa também editar o www/index.php:
  // Modificar require __DIR__.'/../bootstrap/autoload.php'; $app = require_once __DIR__.'/../bootstrap/start.php';
  // Para require __DIR__.'/../laravel/bootstrap/autoload.php'; $app = require_once __DIR__.'/../laravel/bootstrap/start.php';
  
  Isso deve ser o suficiente.
  
  Com relação ao uso do Laravel para desenvolver um sistema grande, eu acho uma boa sim. Principalmente pela qualidade do código que se obtém usando o Laravel. Facilita a manutenção no futuro e diminui algumas horas de trabalho. Se você está muito preocupado com a performance, pode usar um framework mais leve, como o CodeIgniter. Mas no final das contas o que vai pesar mais é o acesso ao banco de dados e tanto no Laravel como no CodeIgniter você pode criar queries bem complexas usando todos os joins necessários para otimizar a consulta.
  
  Para aprender mais tem um livro em http://daylerees.com/codebright que você pode acessar pelo site ou comprar o PDF (tem em PT-BR se preferir) que é bem interessante. Ele te apresenta o básico para começar e depois, quando você encontrar algum problema específico, recomendo o Google mesmo 😉
  
  Abraço
  Responder
  1. roberto alam disse:
    
    24 de agosto de 2016 às 17:14
    
    interessante esse método , achei que do meu jeito seria mais fácil, mas por não ter conhecimento no frameword não rolou …
    tentei configurar o .htaccess da raiz e da pasta public conforme esse exemplo:
    
    https://www.reddit.com/r/laravel/comments/3mvs01/problem_with_notfoundhttpexception/
    
    só que não funcionou 🙁
    continuo com o erro : NotFoundHttpException in RouteCollection.php line 161:
    
    se você tiver uma outra dica … fico no aguardo.
    
    Responder
    1. Oscar Dias disse:
      
      24 de agosto de 2016 às 19:29
      
      Boa tarde Roberto,
      
      Não sei se entendi sua dúvida. Pelo link que você mandou o problema era que o /public aparecia na URL. É este seu problema? Caso seja, não precisa mudar o .htaccess, mas sim o endereço para onde o apache ou o nginx está apontando – deve ser para a pasta public. Isso é diferente de outros frameworks, como o CodeIgniter por exemplo.
      
      Outra coisa, esse meu artigo é bem antigo, então sempre valida na documentação oficial do Laravel.
      
      Abraço
      
      Responder
Isaque Rocha disse:

18 de agosto de 2014 às 00:01

Muito boa essa série, terá alguma continuação?

Responder
1. Oscar Dias disse:
  
  18 de agosto de 2014 às 01:34
  
  Oi Isaque,
  
  Terá continuação sim. O tempo que está curto para escrever, mas durante essa semana pretendo publicar o próximo.
  
  Abraço
  
  Responder
Giovani Hardt disse:

6 de setembro de 2014 às 03:22

Notei que para o usuarios e reminders, é usado o email como campo chave, mas se criar uma aplicação onde o campo chave não seja esse, e sim o username, como fazer?

Responder
1. Oscar Dias disse:
  
  12 de setembro de 2014 às 22:42
  
  Para os usuários você pode substituir ou acrescentar um campo usuário sem problema. Recomendo usar um índice único para não repetir o campo. É claro que para enviar o reminder é necessário um e-mail.
  
  Responder
Abimael disse:

16 de outubro de 2014 às 20:11

Muito legal seu tutorial, sou meio “Burro”rsss e fiz de boa sem problemas e sem erros, deu para entender bem.

Estou fazendo a parte de inclusão dos usuários porem me deparei com um problema meio besta, a parte de senha e a lista Tipo(Autor e Admim) fiz assim:

Senha
{{ Form::password(‘senha’, ”, array(‘class’ => ‘form-control’, ‘placeholder’ => ‘Senha’)) }}

Tipo
{{ Form::select(‘size’, array(‘L’ => ‘Admin’, ‘S’ => ‘Autor’), ‘S’); }}

Porem perde a formatação do CSS, você poderia me dizer como arrumar isso?

Muito obrigado e parabéns pelo tutorial.
Abimael

Responder
1. Oscar Dias disse:
  
  16 de outubro de 2014 às 21:59
  
  Tudo bem, que bom que você está curtindo.
  Com relação a senha, não tem o segundo parâmetro, pois a senha nunca é enviada para a view, então fica assim:
  {{ Form::password(‘senha’, array(‘class’ => ‘form-control’, ‘placeholder’ => ‘Senha’)) }}
  
  No tipo de usuário, faltou definir a classe. Deve ser desta maneira:
  {{ Form::select(‘size’, array(‘L’ => ‘Admin’, ‘S’ => ‘Autor’), ‘S’, array(‘class’ => ‘form-control’)) }}
  
  Neste último select você pode passar no terceiro parâmetro $registro->size para buscar o valor do banco.
  
  Abraço
  
  Responder
  1. Abimael disse:
    
    18 de outubro de 2014 às 02:09
    
    O que eu não entendi foi este terceiro parâmetro $registro->size
    
    Responder
    1. Oscar Dias disse:
      
      18 de outubro de 2014 às 03:12
      
      O terceiro parâmetro da função Form::select() é a opção que vai aparecer marcada na tela. No exemplo você usou o campo “size”, por isso usei o mesmo campo. Se este campo for do usuário você pode usar:
      {{ Form::select(‘size’, array(‘L’ => ‘Admin’, ‘S’ => ‘Autor’), $usuario->size, array(‘class’ => ‘form-control’)) }}
      
      No meu exemplo era o tipo do usuário, portanto era assim:
      {{ Form::select(‘tipo’, array(‘admin’ => ‘Admin’, ‘autor’ => ‘Autor’), $usuario->tipo, array(‘class’ => ‘form-control’)) }}
      
      Percebe que eu usei o nome do select igual ao nome do campo da tabela: select name=”tipo” e $usuario->tipo.
      
      Responder
      1. Abimael disse:
        
        20 de outubro de 2014 às 11:46
        
        Cara muiiiito obrigado!
        
        Ja tentei aprender, Zend, CakePHP, Codeigniter entre outros que dei uma fuçada… Estas ferramentas não me deram aquele “Tcham” como deu o Laravel, não só por que ele é fácil de se aprender, mas também por que as outras ferramentas não apresentam um tutorial bacana como o seu, espero que estes tutorias continuem. Valeu mesmo!
        
        Abraços,
        Abimael
João Mello disse:

20 de outubro de 2014 às 22:45

Muito bom mesmo, aguardo ansioso para continuar.
Gostei muito mesmo do controle de Acesso, muito fácil de aprender.

Responder
leandro disse:

20 de outubro de 2014 às 23:45

Obrigado pelo tutorial, aprendi bastante coisas – considerando que sou leigo.

No caso, baixei a versão 1.5 – quando fui testar ao inserir o artigo – resultou em mensagem de erro: ErrorException – Creating default object from empty value

na parte:

public function postEditar()
{
$artigo = Artigo::find(Input::get(‘id’));

$artigo->titulo = Input::get(‘titulo’);
$artigo->conteudo = Input::get(‘conteudo’);

O q poderia ter acontecido?

Responder
1. Oscar Dias disse:
  
  21 de outubro de 2014 às 01:01
  
  Tudo bem Leandro… Estranho este erro. Quando você acessa a página de edição do artigo e verifica o código fonte, há uma linha como a de baixo?
  
  Este input será usado para buscar o artigo no post. Se ele não encontrar um post, vai retornar false e não será possível acessar o objeto, retornando o erro que você encontrou…
  
  Responder
2. João Mello disse:
  
  22 de outubro de 2014 às 20:41
  
  Comigo também aconteceu este erro, mas só ouve um pequeno “erro” no script de inserir que está direcionando para editar, mas é para inserir.
  
  {{ Form::open(array('url' => 'artigos/inserir', 'class' => 'form-horizontal', 'role' => 'form')) }}
  Por isso o erro, pois não é enviado nenhum ID.
  
  Responder
  1. Oscar Dias disse:
    
    23 de outubro de 2014 às 00:01
    
    Deve ser isso mesmo. A correção já havia sido feita, mas faltou publicar um novo release. Agora está feito.
    
    Responder
leandro disse:

21 de outubro de 2014 às 17:05

http://i.imgur.com/0Hshz0m.png

Qual linha?

Responder
Everaldo disse:

24 de novembro de 2014 às 19:22

Muito boa a sua iniciativa. Comecei a estudar o Laravel, mas estava com dificuldades para achar material bom e explicativo. Achei. Quando pretende escrever mais sobre o assunto. Obrigado.

Responder
Fernando Maio disse:

8 de março de 2015 às 22:56

Oscar, muito bom seu tutorial! Aprendi muito e criei gosto em trabalhar com o Laravel!
Eu comecei a estudar na semana em que saiu o Laravel 5, mas fiz questão de estudar seu tutorial pra pegar uma base do framework, e pelo que eu já vi da versão 5, vai me ajudar bastante!
Parabéns e muito obrigado por compartilhar seu conhecimento cara!

Abraço!

Responder
Rafael Aguiar disse:

20 de outubro de 2015 às 15:18

Primeiramente parabéns pelo artigo ficou muito bom e simples, agora tenho uma duvida vamos ver se consegue me ajudar.
Eu gostaria de poder controlar permissões dentro das views, ou seja, pode ocultar alguns botoes que o usuário não tem permissão, como na sua opinião seria a melhor pratica para isso?

Desde já agradeço a atenção.

Responder
1. Oscar Dias disse:
  
  20 de outubro de 2015 às 20:22
  
  Rafael, existem várias maneiras de fazer isso. Se as permissões no seu aplicativo forem fixas, pode fazer algo como:
  @if(\Auth::user()->perfil == 'admin') ... @endif
  Caso você precise de permissões dinâmicas, onde o próprio usuário vai poder definir quem acessa cada componente, você vai precisar fazer isso através de banco de dados. Você pode criar uma tabela perfis (id, nome), outra funcionalidades (id, nome, url – essa lista de funcionalidade você pode criar uma classe e colocar hardcoded no código para simplificar) e outra acessos (id, perfil_id, funcionalidade_id, acesso (sim/não)) e um método no User model verificando se o usuário possui acesso a URL desejada. Nesse caso dinâmico tudo vai depender de como você organiza seu código… talvez a URL não seja o melhor caminho para controlar isso.
  
  E sempre lembra de verificar a permissão no controller ou rota. Mesmo que você esconda um botão não quer dizer que o usuário não vai acessar o link simplesmente mudando a URL no browser.
  
  Responder
Henrique disse:

4 de dezembro de 2015 às 18:36

Gostaria de agradecer pelo artigo, está me ajudando muito, mas ficaram algumas dúvidas, estou usando uma tabela de usuários onde os campos tem um padrão de nomenclatura diferente, por exemplo: usu_id, usu_nome, usu_email, etc.
Seguindo os passos do artigo, montei o formulário de login e configurei para os nomes corretos do meu banco de dados, mas quando vou efetuar o login ele apresenta a mensagem “E-mail ou senha inválidos”.
Tem mais alguma classe que preciso alterar os nomes dos campos, ou tem alguma forma de visualizar o sql que ele está enviando ao banco?

Responder
1. Oscar Dias disse:
  
  4 de dezembro de 2015 às 18:54
  
  O principal é o campo ID. É necessário declarar uma propriedade $primaryKey, assim como fizemos com o $table.
  
  protected $primaryKey = 'usu_id';
  
  Para ver as queries executadas você pode fazer o seguinte:
  DB::enableQueryLog(); // Isso só precisa no Laravel 5 $queries = DB::getQueryLog(); dd($queries); // ou print_r($queries)
  
  Responder
  1. Henrique disse:
    
    7 de dezembro de 2015 às 13:52
    
    Obrigado pela dica, agora deu certo, mas surgiu outras dúvidas, pesquisei na internet sobre como mapear os campos que vem do banco, por exemplo, no banco tenho os campos usu_id, usu_nome, usu_email, … na aplicação eu gostaria de usar no formato Usuario->id, Usuario->nome, … Vi em um site em inglês a propriedade protected $maps = [], que aparentemente faria isso, mas não deu certo. Existe um meio de fazer essa conversão nos nomes dos campos automaticamente?
    
    Responder
    1. Oscar Dias disse:
      
      7 de dezembro de 2015 às 16:52
      
      Acho que a melhor saída para você é utilizar o Mappable. Outra alternativa seria fazer getters e setters para cada campo:
      
      public function getNomeAttribute($value) { return $this->attributes['usu_nome']; }
      
      Responder
Sam disse:

8 de janeiro de 2016 às 13:10

Olá,

Muito Bom o tutorial.
Tenho uma dúvida. Não é preciso alterar em app/config/auth.php a tabela padrão de usuários também? Só alteramos o nome do Model :

‘model’ => ‘Usuario’,
‘table’ => ‘usuarios’,

Responder
1. Oscar Dias disse:
  
  11 de janeiro de 2016 às 15:54
  
  Boa tarde,
  
  Não é necessário. Como estamos usando ‘driver’ => ‘eloquent’, o que importa é a propriedade ‘model’. Se você trocar o driver para ‘database’, aí sim terá que atualizar a propriedade ‘table’.
  
  Abraço
  
  Responder
Cassio Bueno disse:

5 de abril de 2016 às 18:08

Cara, vc respondeu a pergunta dele e me ajudou a desvendar um mistério.. kkk
Obrigado pelo tutorial.. espero que continue publicando sempre, muito bom!

Abração ae!!!

Responder
Rafael disse:

24 de janeiro de 2017 às 19:54

olá, parabéns pelo tutorial mais esta aparecendo esse erro

[Symfony\Component\Debug\Exception\FatalThrowableError]
Class ‘Usuario’ not found

quando executo

php artisan db:seed

Sabe oq pode ser?

Obrigado.

Responder
Rafael disse:

24 de janeiro de 2017 às 19:56

olá, parabéns pelo tutorial..

no meu arquivo auth.php não tem:

|————————————————————————–
| Authentication Model
|————————————————————————–
|
| When using the “Eloquent” authentication driver, we need to know which
| Eloquent model should be used to retrieve your users. Of course, it
| is often just the “User” model but you may use whatever you like.
|
*/

‘model’ => ‘Usuario’,

Apenas:

/*
|————————————————————————–
| User Providers
|————————————————————————–
|
| All authentication drivers have a user provider. This defines how the
| users are actually retrieved out of your database or other storage
| mechanisms used by this application to persist your user’s data.
|
| If you have multiple user tables or models you may configure multiple
| sources which represent each model / table. These sources may then
| be assigned to any extra authentication guards you have defined.
|
| Supported: “database”, “eloquent”
|
*/

‘providers’ => [
‘users’ => [
‘driver’ => ‘eloquent’,
‘model’ => App\User::class,
],

Esta aparecendo esse erro

[Symfony\Component\Debug\Exception\FatalThrowableError]
Class ‘Usuario’ not found

quando executo

php artisan db:seed

Sabe oq pode ser?

Obrigado.

Responder
1. Oscar Dias disse:
  
  25 de janeiro de 2017 às 01:55
  
  Qual versão do Laravel? A versão do tutorial era uma versão antiga (acho que 4.2). Você tem que tomar cuidado para o ‘model’ => App\User::class estar apontando para a classe correta.
  Por exemplo, se você renomeou o model para Usuario e moveu ele para dentro do diretório models, é interessante usar o namespace App\Models dentro do model. Nesse caso você precisaria trocar a configuração para ‘model’ => App\Models\Usuario::class.
  
  Responder
uhelliton disse:

4 de julho de 2017 às 14:41

Amigo, muito obrigado por compartilhar um pouco do seu conhecimento.
Excelentes dicas!!!

Responder
Lucas Alves Pereira disse:

20 de novembro de 2020 às 02:56

Olá bom noite.
Não sei se ainda esta ativo!
Poderia atualizar esse tutorial para a nova versão do laravel por gentileza, se não muito encomodo.

Responder
1. Oscar Dias disse:
  
  10 de janeiro de 2021 às 22:04
  
  Infelizmente nos últimos anos não tivemos muito tempo para atualizar os tutoriais. Se conseguirmos retomar isso com certeza vamos focar no Laravel! Abraço
  
  Responder

Contas de Usuário

Banco de Dados

Model

Controle de Acesso

Database Seeding

Autenticação

Bonus – Cadastro de Usuários

Conclusão

Sobre Oscar Dias

36 respostas para “Usuários e Controle de Acesso no Laravel”

Deixe uma resposta Cancelar resposta