37590801?s=460&v=4

A software engineer who dreams about non-electric sheep and autonomous vehicles and likes to champion security.

Software Engineer

Dan Arias

Learn how to use Express and Pug to build a website in Node.js

Build a Website with Node.js and Express

5e074956ee8ba1fea26e30d28c190495?s=300 avatar

5e074956ee8ba1fea26e30d28c190495?s=300

Full stack developer creating content at Auth0. I love taking a deep dive into hard-to-understand concepts and creating content that makes them easier to grasp. In my free time you can usually find me reading, hanging out with my dogs, or curling in the squat rack.

Former Developer Content Manager

Holly Guevara

1097492785caf9ffeebffeb624202d8f?s=200 avatar

1097492785caf9ffeebffeb624202d8f?s=200

Prosper is a great speaker, community leader, open source hacker, technical consultant, and a fervent Developer Advocate. He is a full-stack software engineer who has worked on biometric, health and developer tools. Prosper recently co-founded a startup called Eden that’s focused on improving the quality of lives in Nigeria and currently leads the engineering team. He also co-founded forloop, the largest developer community in Africa.

Former Auth0 Employee

Prosper Otemuyiwa

Learn how to build a Laravel CRUD application that includes authentication.

<div class="alert alert-success alert-icon">
  <i class="icon-budicon-500"></i>
  <strong>Laravel 6.0 is out! Check out <a onclick="window.metricsLib.track('laravel6_crosspost')" href="https://auth0.com/blog/build-a-laravel-6-app-with-authentication/">Build a Laravel 6 CRUD App with Authentication</a> to learn what new things Laravel can do for you.</strong>
</div>

<div class="alert alert-info alert-icon">
  <i class="icon-budicon-487"></i>
  <strong>This blog post covers Laravel 5.8.</strong>
</div>

**TL;DR:** Laravel is a great PHP framework. Currently, it is the most starred PHP project on [Github](https://github.com) and a lot of companies and people all over the world use it to build amazing applications. In this tutorial, I'll show you how easy it is to build a web application with Laravel and add authentication to it without breaking a sweat. Check out the [repo](https://github.com/auth0-blog/laravel-got) to get the code.

---

**Laravel** is a free, open-source PHP framework designed for building web applications with an expressive and elegant syntax. **Laravel** has a high level of abstraction which shields the common developer from complex inner workings. **Laravel** saves you time and effort because it ships with a lot of features out of the box. These amazing features include:

* Database Migrations
* Eloquent ORM
* Authorization and Policies
* Scheduler
* Queuing

**Laravel** makes good use of already written and well-tested components from the PHP community. It is one of the few frameworks that comes with development environments such as [Homestead](https://laravel.com/docs/5.8/homestead) and [Valet](https://laravel.com/docs/5.8/valet). The [documentation](https://laravel.com/docs) is very detailed and there is a large community based around Laravel. Some of the notable communities are [laracasts.com](https://laracasts.com/discuss), [larajobs.com](https://larajobs.com/), [laravel-news.com](https://laravel-news.com/), [laravelpodcast.com](http://www.laravelpodcast.com/) and [larachat.co](https://larachat.co/).

<include src="TweetQuote" quoteText="Laravel is one of the few frameworks that actually with development environments such as Homestead"/>

We'll be building a simple character listing app with **Laravel 5.8**. Our app will simply list **10 Game of Thrones characters** and their real names. Once we add authentication to the app, all logged-in users will have the privilege of knowing these celebrity characters personally.

## Let's Get Started

Laravel utilizes [Composer](http://getcomposer.org/) to manage its dependencies. So, before using Laravel, make sure you have Composer installed on your machine. We can install Laravel by issuing the Composer `create-project` command in your terminal like so: `composer create-project --prefer-dist laravel/laravel GOT` or using the `laravel` installer.

It's faster to spin up a new app using the `laravel` command like so: `laravel new GOT`. Check out the Laravel [docs](https://laravel.com/docs/5.8#installing-laravel) to learn how to set up the Laravel installer.

If you used the `laravel` installer command to create a new app, then you have to run `composer install` immediately after the previous command to install all the dependencies.

Now run the following in your terminal to launch your application:

```bash
php artisan serve
```

## Explore Directory Structure

Laravel applications follow the **Model-View-Controller** design pattern.

![Laravel app model view controller architecture diagram](https://images.ctfassets.net/23aumh6u8s0i/4CbISa5h2k6Op4g7Hp6DrQ/7478ae9f2bbdb66bec115642ce827137/mvc-diagram)

*(Source: [Self Taught Coders](https://selftaughtcoders.com))*

In a nutshell,

  * **Models** query your database and return the necessary data.
  * **Views** are pages that render data
  * **Controllers** handle user requests, retrieve data from the models, and pass them to the views.

Read more about [MVC](http://www.tomdalling.com/blog/software-design/model-view-controller-explained/) here.

The app directory is the **meat** of your Laravel application. It houses the following directories:

  * `Console` - Contains all your Artisan commands
  * `Http` - Contains all your controllers, middleware, requests, and routes file
  * `Providers` - Contains all your application service providers. You can read more about [Service Providers](https://laravel.com/docs/5.8/providers) here
  * `Events` - Contains all your event classes
  * `Exceptions` - Contains your application exception handler and custom exception classes
  * `Jobs` - Contains all the jobs queued by your application
  * `Listeners` - Contains all the handler classes for your events
  * `Policies` - Contains the authorization policy classes for your application. Policies are used to determine if a user can perform a given action against a resource.

The other directories namely:

  * `boostrap` contains your framework autoloading files and generated cache files
  * `config` contains your app's configuration files
  * `database` contains your database migrations and seeds
  * `public` contains your assets (images, JavaScript, css, etc.)
  * `resources` contains your views and localization files
  * `storage` contains all your compiled Blade templates, file caches, and logs
  * `tests` contains all your tests
  * `vendor` contains your app dependencies


## Setting Up The Controller

Open up your terminal and in the project root directory, run the command below to create a `ListController`.

```bash
php artisan make:controller ListController
```

Open up `app/Http/Controllers/ListController.php` and configure it like so:

```php
<?php

namespace App\Http\Controllers;

class ListController extends Controller
{
    public function show()
    {
       $characters = [
         'Daenerys Targaryen' => 'Emilia Clarke',
         'Jon Snow'           => 'Kit Harington',
         'Arya Stark'         => 'Maisie Williams',
         'Melisandre'         => 'Carice van Houten',
         'Khal Drogo'         => 'Jason Momoa',
         'Tyrion Lannister'   => 'Peter Dinklage',
         'Ramsay Bolton'      => 'Iwan Rheon',
         'Petyr Baelish'      => 'Aidan Gillen',
         'Brienne of Tarth'   => 'Gwendoline Christie',
         'Lord Varys'         => 'Conleth Hill'
       ];

       return view('welcome')->withCharacters($characters);
    }
}
```

`view('welcome')->withCharacters($characters)` indicates that we are passing the `$characters` array to a view called `welcome.blade.php`. We'll create that view later in this post.

## Setting Up The Model

Laravel models are stored by default in the root of the `app` directory. The `User` model ships with the Laravel framework. Only the `User` model is needed in this application so we won't create any additional models. However, if you want to create more models, you can simply run the command below like so:

```bash
php artisan make:model <modelName>
```

where `<modelName>` represents the name of the model you want to create.

## Setting Up The Routes

Open up `routes/web.php` and configure it like so:

```php
/*
|--------------------------------------------------------------------------
| Application Routes
|--------------------------------------------------------------------------
|
| Here is where you can register all of the routes for an application.
| It's a breeze. Simply tell Laravel the URIs it should respond to
| and give it the controller to call when that URI is requested.
|
*/

Route::get('/', 'ListController@show');
```

Once a request hits the `/` route, it invokes the `show` method of the `ListController` and renders the returned value in the `welcome` view. We'll configure the `welcome` view later in this post.

## Setting Up Authentication

We're going to be using Auth0 for authentication. Setting up the built-in authentication with Laravel is pretty **straightforward, but limited**. With Auth0, you'll have access to an easy-to-use dashboard, the ability to integrate social identity providers, two-factor authentication, passwordless login, and more. And luckily, it's just as easy to integrate with your Laravel application! Let's check it out.

If you don't already have an account, go ahead and <a href="https://a0.to/blog_signup" data-amp-replace="CLIENT_ID" data-amp-addparams="anonId=CLIENT_ID(cid-scope-cookie-fallback-name)">sign up for a free Auth0 account here</a>.

<include src="SignupCTA" text="Try out the most powerful authentication platform for free." linkText="Get started →" />

After you've signed up, head to the dashboard and click on "Applications". Click on "Create Application" and name the application "Laravel App" or anything you'd like. Then click on "Regular Web Application" and press create.

Next, you need to add the valid callback URLs and logout URLs in the dashboard.

Click on "Applications" and select the application you just created (or the default one). Next, click on "Settings".

Update these values as follows:

* Allowed callback URLs: `http://localhost:8000/auth0/callback`
* Logout URLs: `http://localhost:8000`

Next, go back to your terminal and install the [Auth0 PHP plugin](https://github.com/auth0/auth0-PHP) and [Auth0 Laravel plugin](https://github.com/auth0/laravel-auth0):

```bash
composer require auth0/login:"~5.0"
```

Now open the `config/app.php` file and add the Auth0 login service provider to the list of providers:

```php
// ...
'providers' => [
    // ...
    Auth0\Login\LoginServiceProvider::class,
];
```

Then scroll down to the `aliases` array and add the Auth0 facade:

```php
// ...
'aliases' => [
    // ...
    'Auth0' => Auth0\Login\Facade\Auth0::class,
];
```

Next, open `app/Providers/AppServiceProvider.php` and add the following under `register()`:

```php
// ...
class AppServiceProvider extends ServiceProvider
{
  // ...
  public function register()
  {
    $this->app->bind(
      \Auth0\Login\Contract\Auth0UserRepository::class,
      \Auth0\Login\Repository\Auth0UserRepository::class
    );
  }
}
```

You need to publish the plugin configuration. In your terminal, run:

```bash
php artisan vendor:publish
```

When it asks which file you'd like to publish, select `Auth0\Login\LoginServiceProvider`.

This will create the `config/laravel-auth0.php` file. Open this up now and you'll see it's using some Auth0 variables. These are sensitive, so you need to add them to the `.env` file.

Open up `.env` and add:

```
AUTH0_DOMAIN=your-auth0-domain.auth0.com
AUTH0_CLIENT_ID=your-client-id
AUTH0_CLIENT_SECRET=your-client-secret
```

To fill in these values, head back to [your Auth0 dashboard](https://manage.auth0.com/dashboard/), select your application, and click on "Settings".

While you have `.env` open, double-check that `APP_URL` matches your dev URL exactly, **including the port**. It should say `APP_URL=http://localhost:8000`. If not, update that now.

The last configuration step is to switch out the Laravel user driver to use Auth0.

Open up `config/auth.php`, scroll down to `providers`, and paste in:

```php
'providers' => [
  'users' => [
    'driver' => 'auth0',
  ],
],
```

Now that you have the Auth0 plugin configured, you just need to integrate it into the application.

### Integrating Auth0

Open up `routes/web.php` and add these authentication routes:

```php
Route::get( '/auth0/callback', '\Auth0\Login\Auth0Controller@callback' )->name( 'auth0-callback' );
Route::get( '/login', 'Auth\Auth0IndexController@login' )->name( 'login' );
Route::get( '/logout', 'Auth\Auth0IndexController@logout' )->name( 'logout' )->middleware('auth');
```

These routes will handle the login, logout, and redirect to Auth0 during login. Now you need to create that `Auth0IndexController`.

In your terminal, run:

```bash
php artisan make:controller Auth/Auth0IndexController
```

Open up `app/Http/Controllers/Auth/Auth0IndexController.php` and replace it with:

```php
<?php

namespace App\Http\Controllers\Auth;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class Auth0IndexController extends Controller
{
  /**
    * Redirect to the Auth0 hosted login page
    *
    * @return mixed
    */
  public function login()
  {
    $authorize_params = [
      'scope' => 'openid profile email',
    ];
    return \App::make('auth0')->login(null, null, $authorize_params);
  }

  /**
    * Log out of Auth0
    *
    * @return mixed
    */
  public function logout()
  {
    \Auth::logout();
    $logoutUrl = sprintf(
      'https://%s/v2/logout?client_id=%s&returnTo=%s',
      env('AUTH0_DOMAIN'),
      env('AUTH0_CLIENT_ID'),
      env('APP_URL'));
    return  \Redirect::intended($logoutUrl);
  }
}
```

The scopes being requested in the `login()` function are: `openid`, `profile`, and `email`.

There is also a `logout()` function that will clear all session data to log the user out.

Now it's time to wire up the buttons so that users can sign in and out.

Open up your `welcome.blade.php` and configure it like so:

``` html  

<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
  <head>
      <meta charset="utf-8">
      <meta name="viewport" content="width=device-width, initial-scale=1">
      <title>Laravel</title>
  </head>
  <body>
    <div class="flex-center position-ref full-height">
      @if (Route::has('login'))
      <div class="top-right links">
        @if(Auth::user())
          <a href="{{ url('/home') }}">Home</a>
          <a href="{{ url('/logout') }}">Logout</a>
        @else
          <a href="{{ route('login') }}">Login</a>
        @endif
      </div>
      @endif
      <div class="container">
        <div class="row">
          <div class="col-md-10 col-md-offset-1">
            <div class="panel panel-success">
              <div class="panel-heading">List of Game of Thrones Characters</div>
              @if(Auth::user())
              
              <table class="table">
                <tr>
                  <th>Character</th>
                  <th>Real Name</th>
                </tr>
                @foreach($characters as $key => $value)
                  <tr>
                  <td>{{ $key }}</td><td>{{ $value }}</td>
                  </tr>
                @endforeach
              </table>
              @endif
            </div>
            @if(Auth::guest())
            <a href="/login" class="btn btn-info"> You need to login to see the list 😜😜 >></a>
            @endif
          </div>
        </div>
      </div>
    </div>
  </body>
</html>

```

Here, we are looping through the `$characters` array data passed from the `ListController` for appropriate rendering in the `welcome` view.

`Auth::user()` &mdash; You can check if a user is authenticated or not via this method from the `Auth` Facade. It returns true if a user is logged-in and false if a user is not. Check [here](https://laravel.com/docs/5.8/facades) for more about how Facades work in Laravel.

`Auth::guest()` &mdash; This does the opposite of `Auth::user()`. It returns true if a user is not logged in and false if a user is logged in. Check [here](https://laravel.com/api/5.8/Illuminate/Auth/Guard.html) to see all the methods you can call on the `Auth` Facade.

Now that we have all the routes and views setup, your application should look like this:

_Landing Page_

![Laravel application localhost home page](https://images.ctfassets.net/23aumh6u8s0i/1mO2iyeAn8ijE7WmOUkuxz/929a7e2a22b698b17c28357653fc4578/landing-page)

If you were to implement authentication on your own, you might have a login and register page like this:

_Login Page_

![Laravel login page](https://images.ctfassets.net/23aumh6u8s0i/7q90WhvMPGyPqhh5XfG15z/e77f3d9251c3c15102f6066159a7690d/login-page)

_Register Page_

![Laravel register page](https://images.ctfassets.net/23aumh6u8s0i/6ac6bOkZkfTwvseGxCMFO0/897b07d6843f752d742867817baf6a6e/register-page)

Because we're using Auth0 for authentication, our application will redirect users to the Auth0 login page, so you don't have to create these on your own!

## Using the Auth Middleware

Middlewares provide a convenient mechanism for filtering HTTP requests entering your application. For example, **Laravel** includes a middleware that verifies the user of your application is authenticated. If the user is not authenticated, the middleware will redirect the user to the login screen. However, if the user is authenticated, the middleware will allow the request to proceed further. The `app/Http/Middleware` directory contains several middleware.

Let's check out how the `auth` middleware works.

Add a new route to your `routes/web.php` file like so:

```php
Route::get('/got', [
  'middleware' => ['auth'],
  'uses' => function () {
    echo "You are allowed to view this page!";
}]);
```

If you're still logged in, head to [http://localhost:8000/got](http://localhost:8000/got) and you should get the message "You are allowed to view this page!". Now, log out, then try to access that route and you will be redirected back to Auth0 to sign in. 

The Laravel `auth` middleware intercepted the request, checked if the user was logged-in, discovered that the user was not logged-in, then redirected the user back to the `login` route, which sent them to Auth0.

## Wrapping Up

Well done! You have just built your first app with Laravel. Laravel is an awesome framework to work with. It focuses on simplicity, clarity and getting work done. As we saw in this tutorial, you can easily activate the built-in authentication to your Laravel applications. If you find yourself needing more, you can also integrate Auth0 just as easily.

Please, let me know if you have any questions or observations in the comment section. 😊

Creating Your First Laravel App and Adding Authentication

Learn how to use Passport.js to add user authentication to a web app built with Node.js and Express.

Node.js and Express Authentication Using Passport

olususi-oluyemi

Oluyemi is a tech enthusiast with a background in Telecommunication Engineering. He ventured into programming with a keen interest in solving day-to-day problems encountered by users. He has since directed his problem-solving skills towards building software for both the web and mobile platforms. As a full-stack software engineer with a passion for sharing knowledge, Oluyemi has published many technical articles and content on several blogs worldwide. As s tech-savvy person, his hobbies include trying out new programming languages and frameworks.

Software Engineer / Technical Content Creator

Olususi Oluyemi

Learn how to build your first Symfony application and add authentication to it.

Creating your First Symfony App and Adding Authentication

ramiro

I am an internet guy who loves reading and asking questions—those are the two things that helped me the most as an autodidact 🤓. If I am not learning about the latest trends in digital marketing or listening to house music, you can probably find me watching a tennis tournament. And also, I manage Social Media at Auth0 ✌️

Manager, Social Media

Ramiro Nunez Dosio

Explore the complexities of authentication and how to solve them on this stream from .NET Conf 2019.



.NET Conf 2019 was an exciting and unique event that took place this year from September 23 — 25. It is a free, 3-day virtual conference co-organized by the .NET community and Microsoft. Anyone with an Internet connection was able to attend.

## .NET Conf 2019: A Virtual Conference

This year the conference saw the [launch of .NET Core 3.0](https://auth0.com/blog/exploring-dotnet-core-3-whats-new/), offered prizes to attendees such as free Xbox One X consoles, and hosted talks from a world-class lineup of speakers from Microsoft and the community.

Our own [Developer Advocate Engineer Bobby Johnson](https://auth0.com/blog/authors/bobby-johnson/) gave a talk focused on exploring how the username-password strategy got so complicated over time. Bobby shows you how overwhelming it can be to take your first step beyond username and password-based authentication strategies, which are the default authentication strategies offered by most full-stack web application frameworks.

Social logins, Identity Providers, OAuth 2.0, LDAP, SAML, OpenId Connect; all can be confusing. What does it all mean? How did we get here? Watch Bobby's talk to find out:

<AmpContent>
  <amp-iframe width="480" height="270"
    sandbox="allow-scripts allow-same-origin"
    layout="responsive"
    frameborder="0"
    src="https://www.youtube.com/embed/ga3u_4B7_Bw?start=69">
  </amp-iframe>

</AmpContent>

<NonAmpContent>

  <iframe width="560" height="315" src="https://www.youtube.com/embed/ga3u_4B7_Bw?start=69" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

</NonAmpContent>

<include src="ProfileCard" picture="https://cdn.auth0.com/blog/auziros/bobby-johnson.png" name="Bobby Johnson" title="Developer Advocate Engineer" team="Technical Experience" location="Washington, United States" body="Attending .NET Conf 2019 and collaborating with the Channel 9 team was an awesome experience. They were very professional and the event ran like clockwork."/>

The organizers have made all the sessions available [on-demand on YouTube](https://www.youtube.com/user/VisualStudio). Be sure to check them out.

## More Resources

- [.NET Conf 2019 Official Site](https://www.dotnetconf.net/)

- [Bobby's Twitch Channel](https://www.twitch.tv/iamnotmyself/): Streams three times per week!

- [The Live Coders' Twitch Channel](https://livecoders.dev/): Enthusiastic streaming developer community with members who participated in .NET Conf 2019 as organizers or attendees.

- [Exploring .NET Core 3.0. What's New?](https://auth0.com/blog/exploring-dotnet-core-3-whats-new/)

- [Building and Securing Web APIs with ASP.NET Core 3.0](https://auth0.com/blog/how-to-build-and-secure-web-apis-with-aspnet-core-3)

## Aside: Securing ASP.NET Core 3.0 with Auth0

Authentication and authorization are hard but securing ASP.NET Core 3.0 applications with Auth0 is easy and brings a lot of great features to the table. With [Auth0](https://auth0.com/), you only have to write a few lines of code to get solid [identity management solution](https://auth0.com/user-management), [single sign-on](https://auth0.com/docs/sso/single-sign-on), support for [social identity providers (like Facebook, GitHub, Twitter, etc.)](https://auth0.com/docs/identityproviders), and support for [enterprise identity providers (like Active Directory, LDAP, SAML, custom, etc.)](https://auth0.com/enterprise).

<AmpContent>
<amp-youtube
    data-videoid="U3NDciLTTgI"
    layout="responsive"
    width="480" height="270">
</amp-youtube>

</AmpContent>

<NonAmpContent>

<iframe width="560" height="315" src="https://www.youtube.com/embed/U3NDciLTTgI" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

</NonAmpContent>

On ASP.NET Core 3.0, you need [to create an API in your Auth0 Management Dashboard](https://auth0.com/docs/apis) and change two things on your code. To create an API, you need to <a href="https://auth0.com/signup" data-amp-replace="CLIENT_ID" data-amp-addparams="anonId=CLIENT_ID(cid-scope-cookie-fallback-name)">sign up for a free Auth0 account</a>. After that, you need to go to [the API section of the dashboard](https://manage.auth0.com/#/apis) and click on "Create API". On the dialog shown, you can set the _Name_ of our API as "Books", the _Identifier_ as "http://books.mycompany.com", and leave the _Signing Algorithm_ as "RS256".

![Creating API on Auth0](https://images.ctfassets.net/23aumh6u8s0i/EqGkwFxCdRtjWblGcRHo8/4d14728749a8c8db52447c6a4f62713d/creating-api-on-auth0)

After that, you have to add the call to `services.AddAuthentication` in the `ConfigureServices` method of `Startup`:

```csharp
string domain = $"https://{Configuration["Auth0:Domain"]}/";
services.AddAuthentication(options =>
{
  options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
  options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
  options.Authority = domain;
  options.Audience = Configuration["Auth0:Audience"];
});
```

You also need to add an invocation to `app.UseAuthentication()` in the body of `Configure()` method of `Startup`.

And add the following element to `appsettings.json`:

```json
{
  "Logging": {
    // ...
  },
  "Auth0": {
    "Domain": "bk-samples.auth0.com",
    "Audience": "http://books.mycompany.com"
  }
}
```

> **Note** that the domain, in this case, **has to be changed** to the domain that you specified when creating your Auth0 account.


How Usernames and Passwords Got so Complicated

bruno-krebs

I am passionate about developing highly scalable, resilient applications. I love everything from the database, to microservices (Kubernetes, Docker, etc), to the frontend. I find amazing to think about how all pieces work together to provide a fast and pleasurable experience to end users, mainly because they have no clue how complex that "simple" app is.

R&D Content Architect

Bruno Krebs

Learn how to use Django to build web applications easily, and Auth0 to make the process even faster and more secure.

Django Tutorial: Building and Securing Web Applications

obielum-godson

I am a Software Developer with a life goal of using technology as a tool for solving problems across the major industries in the world. My expertise lies in languages and frameworks such as Angular, React, Java, and Node. I also love writing and see it as one of the most efficient ways of teaching/passing down information about basically any subject.

Full-Stack Developer

Obielum Godson

Learn how to develop a real-time web app that enables multiple users to work on the same document with ease.

Developing a Real-Time, Collaborative Editor with Pusher

Laravel 5.7 has just been released! What's new? What improvements were made? Learn how to build better PHP applications with this new release.



**TL;DR:** **Laravel 5.7** is a major release to, at time of writing, the most popular PHP framework on GitHub. Furthermore, [Laravel Nova](https://nova.laravel.com) was also released. In this article, I'll cover the new features in Laravel 5.7 and several other changes and deprecations.

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">🎊 Laravel 5.7.0 has been released! Includes support for email verification, guest policies, dump-server, improved console testing, notification localization and more! <a href="https://t.co/DIISmfm5oP">https://t.co/DIISmfm5oP</a> 🎊</p>&mdash; Laravel (@laravelphp) <a href="https://twitter.com/laravelphp/status/1036971212449243136?ref_src=twsrc%5Etfw">September 4, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>


## What's new in Laravel 5.7?

### 1. Symfony Dump Server Integration

Marcel Pociot, authored a package called [laravel-dump-server](https://github.com/beyondcode/laravel-dump-server). This package provides you a dump server, that collects all your `dump` call outputs. It's inspired by [Symfony's Var-Dump Server](https://symfony.com/doc/current/components/var_dumper.html#the-dump-server).

Laravel 5.7 now officially ships with the _laravel_dump-server_ package and makes it available via the Artisan command:

```bash
php artisan dump-server
```

All `dump` calls will be displayed in the console window once the server has started.

![Laravel - Symfony Dump Server Integration](https://images.ctfassets.net/23aumh6u8s0i/6ZdDoNQrq8O2YAJG94bCoA/3b99720eb2119591f1d8546e4fc8f73d/laravel-dump-server)
_Source: murze.be_

### 2. Better Support For Filesystem

Laravel 5.7 ships with two new methods for reading and writing streams in the filesystem. They are `readStream` and `writeStream` methods for reading and writing streams respectively as shown in the example below:

```php
Storage::disk('s3')->writeStream(
    'new-package.zip',
    Storage::disk('local')->readStream('local-package.zip')
);
```

### 3. Improved Artisan Command Testing

Laravel 5.7 provides a better approach for testing artisan commands.

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">ICYMI Last week a new PR was merged into laravel 5.7 with a neat way for testing Artisan commands, check details here: <a href="https://t.co/36f9FbAhBI">https://t.co/36f9FbAhBI</a> <a href="https://t.co/pLC3sVLrJP">pic.twitter.com/pLC3sVLrJP</a></p>&mdash; Mohamed Said🐋 (@themsaid) <a href="https://twitter.com/themsaid/status/1033954657226420224?ref_src=twsrc%5Etfw">August 27, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

Check out the example below:

This is an Artisan command:

```php
Artisan::command('hackathon-starter:init', function () {
    $project = $this->ask('What type of project do you want to build?');

    $this->line('Initializing...');

    $answer = $this->choice('Which language do you program in?', [
        'pwa-on-steroids',
        'pwa-normal',
        'pwa-on-fire',
    ]);

    $this->line('Installing...');
});
```

You may now test the command above with the slick test approach below:

```php
/**
 * Test a console command.
 *
 * @return void
 */
public function test_console_command()
{
    $this->artisan('hackathon-starter:init')
         ->expectsQuestion('What type of project do you want to build?', 'PWA')
         ->expectsOutput('Initializing..')
         ->expectsQuestion('Please specify the type of PWA', 'pwa-on-fire')
         ->expectsOutput('Installing...')
         ->assertExitCode(0);
}
```


<include src="TweetQuote" quoteText = "Laravel 5.7 provides a better approach for testing artisan commands."/>

### 4. Multi-Lingual Support for Notifications

In Laravel 5.7, you can now send notifications in other locales, apart from the current language.

The `Illuminate\Notifications\Notification` class offers a `locale` method that can be invoked to set the preferred language.

```php
  $user->notify((new EmailSent($email))->locale('zh'));
```

```php
  Notification::locale('zh')->send($users, new EmailSent($email));
```

### 5. Paginator

By default, Laravel provides three links on each side of the primary paginator links.

In Laravel 5.7, there's a new option, `onEachSide`, to enable customization of the number of links displayed on both sides.

``` html  

 {{ $paginator->onEachSide(7)->links() }}

```

### 6. More Options for Guest Policies

By default, authorization gates and policies return _false_ for guest visitors to your application. In this new release, you can now allow unauthenticated visitors to pass through authorization checks by declaring an "optional" type-hint or supplying a `null` default value for the user argument.

```
Gate::define('modify-sheet', function (?User $user, Sheet $sheet) {
    // ...
});
```

### 7. Optional Email Verification

Laravel 5.7 provides an optional email verification feature. An `email_verified_at` timestamp column has to be added to the user's table migration for this feature to work as intended.

If you want new users to verify their email, the `User` model needs to implement the `MustVerfifyEmail` interface.

```php
<?php

namespace App;

use Illuminate\Notifications\Notifiable;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable implements MustVerifyEmail
{
    // ...
}
```

The newly registered users will receive an email containing a signed verification link. Once the user clicks the link, the app will automatically update the database and redirect the user to the intended location.

This feature also ships with a `verified` middleware for situations where you need to protect certain app routes from only verified members.

```php
  'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
```

### 8. Better Support for Development Errors

**Joseph Silber** submitted a PR that allows Laravel 5.7 to provide a clear and concise message when a non-existent method is called on a model.

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">Ever mistyped a method on an Eloquent model and got a cryptic error saying that the method doesn&#39;t exist *on the query builder* 😳<br><br>Well, in <a href="https://twitter.com/laravelphp?ref_src=twsrc%5Etfw">@laravelphp</a> 5.7 you&#39;ll now get a clear, concise message saying that the method doesn&#39;t exist on the model 👌<a href="https://t.co/uKAxbIVdmv">https://t.co/uKAxbIVdmv</a> <a href="https://t.co/aWgQ8zr2ak">pic.twitter.com/aWgQ8zr2ak</a></p>&mdash; Joseph Silber (@joseph_silber) <a href="https://twitter.com/joseph_silber/status/1028768236417036288?ref_src=twsrc%5Etfw">August 12, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

### 9. URL Generator & Callable Syntax

Laravel 5.7 now supports callable array syntax for controller actions that generate URLs.

_Before Laravel 5.7_

```php
$url = action('FoodController@index');

$url = action('FoodController@view', ['id' => 1]);
```

_Now_

```php
$url = action([FoodController::class, 'index']);

$url = action([FoodController::class, 'view'], ['id' => 1]);
```

### 10. Laravel Nova

Taylor already announced that he was working on a project several months ago. The long awaited project called **[Laravel Nova](https://nova.laravel.com)** has been released. Nova is a beautifully designed administration panel for Laravel. It offers support for filters, lenses, actions, queued actions, metrics, authorization, custom tools, custom cards, custom fields, etc.

![Laravel Nova](https://images.ctfassets.net/23aumh6u8s0i/2kxoN45cHorsLSHZgmzhij/509a5bbd27bba13bc0293ca7d57db1cc/screenshot)
_Laravel Nova_


<include src="TweetQuote" quoteText = "As if Laravel 5.7 wasn't enough, @taylorotwell formally introduced @laravel_nova, a beautifully designed administration panel for Laravel."/>

## Deprecations and Other Updates

* The _resources/assets_ directory has been flattened into _resources_.

Check out other [Laravel 5.7 updates on GitHub](https://github.com/laravel/framework/releases/tag/v5.7.0).

## Upgrading to Laravel 5.7

Laravel 5.7 requires `PHP >= 7.1.3`. And the estimated upgrade time from Laravel `v5.6` is about ten to fifteen minutes.

Check out this [comprehensive upgrade guide](https://laravel.com/docs/master/upgrade#upgrade-5.7.0). However, if you don't want to be bothered about manually configuring and changing files for the upgrade, I recommend using [Laravel Shift - A service that provides automated, instant Laravel upgrade services by an army of thorough bots and friendly humans](https://laravelshift.com).

<include src="asides/LaravelBackend" />

## Conclusion

**Laravel 5.7** PHP framework came loaded with new features and significant improvements. And **Nova** is a product every Laravel developer should try out!

Have you upgraded to Laravel v5.7 yet? What are your thoughts? Let me know in the comments section! 😊

<include src="TweetQuote" quoteText = "Laravel 5.7 has been released! Learn what's new in the most popular PHP framework"/>


Laravel 5.7 Release: What's New? 10 Features To Try

idee

Software Engineer building with Kotlin and Flutter.

Software Engineer at Busha

Idorenyin Obong

How to configure a Continuous Deployment pipeline utilizing Now.sh, GitHub, and Travis CI to automate your open-source Node.js web apps.

Continuous Deployment Pipelines and Open-Source Node.js Web Apps

Learn how to develop applications in AngularJS  using a component-based architecture.

New Features for Developing AngularJS Applications - Part 2: Build An App

greg-holmes

I am a Senior Software Engineer for an online estate agent (Housesimple). I am a backend web developer for an online estate agent in Colchester, England. I have been a professional developer since 2011, having worked previously for what used to be a well known and active VPN company, HideMyAss. Aside from web development, some technology that has caught my attention over the years has been the Raspberry Pi.

Guest Author

Greg Holmes

Learn how to create and deploy a secure blog engine with Symfony.

Symfony Tutorial: Building a Blog (Part 3)

Let's create a secure blog engine with Symfony.

Symfony Tutorial: Building a Blog (Part 2)

Laravel 5.6 has officially been released. What's new? What improvements were made? Learn how to build better PHP applications with this new release.



---

**TL;DR:** On Wednesday, February 7, 2018, **Laravel 5.6**, was released to the public. It's a major release to the most popular PHP framework on GitHub as of this writing. Furthermore, [Spark 6.0](https://spark.laravel.com) was also released alongside **Laravel 5.6**. According to the policy laid down by the Taylor and the core team, major Laravel framework releases are released every six months (February and August). In this article, I'll cover the new features in Laravel 5.6 and several other changes and deprecations.

---

Laravel is the most popular, open-source PHP framework as of this writing. It is designed for building web applications with an expressive and elegant syntax. With Laravel, application development is fast because it ships with a lot of features out of the box. Without further ado, let's dive right into **Laravel 5.6**.

## What's new in Laravel 5.6?

### 1. Support For Argon Password Hashing

Argon2, the recommended password hashing algorithm by the [Password Hashing Competition](http://password-hashing.net), is a modern algorithm for securely hashing passwords. And it comes in two distinct flavors, Argon 2i and Argon 2d. PHP 7.2 recently added support for Argon 2i password hashing. Therefore, [Michael Lundbol](https://github.com/morloderex) took the initiative to add support for Argon hashing in Laravel.

![Argon Password Hashing Support](https://images.ctfassets.net/23aumh6u8s0i/5L2DynjxdZyyidmafRBIGB/520c2ffe34b5298eb7e67b62379f7cca/argon)
_Initiative to add Argon Password Hashing_

The `bcrypt` driver is the default driver for password hashing in Laravel. However, Laravel 5.6 now supports `argon`.

![Config File for Hashing](https://images.ctfassets.net/23aumh6u8s0i/2UxXTOybvNMutMq0CSUuMb/09a2461f07e263e59a2311c91a061c1a/argondriversupport)
_Config file for hashing_

**Note:** Laravel 5.6 ships with a [hashing config file](https://github.com/laravel/laravel/blob/develop/config/hashing.php) as displayed above.

### 2. Better Support For Dynamic Rate Limiting

One of the beautiful built-in features of Laravel is _API Rate Limiting_. Before now, Laravel's rate limiting configuration involved specifying a hard-coded number of requests on a group of routes. However, Laravel 5.6 adds icing to the cake by allowing you specify a maximum number of requests based on an authenticated User model attribute.

```php
Route::middleware('auth:api', 'throttle:rate_limit,1')->group(function () {
    Route::get('/users', function () {
        // do something awesome
    });
});
```

In the code above, the `rate_limit` parameter is an attribute of the `User` model in a Laravel 5.6 application.

### 3. Model Serialization on Steriods

Before now, there was a persistent bug on queued models. When queued models are finally processed, it's without their loaded relationships in place.

In Laravel 5.6, huge improvements have been made to ensure that relationships loaded on queued models are automatically re-loaded when the job is processed by the queue.

### 4. Improved Logging

There is a new [logging config](https://github.com/laravel/laravel/blob/develop/config/logging.php) file in Laravel 5.6. In this file, you can set up logging stacks that send log messages to various handlers.

Check out the example below:

```php
'channels' => [
  'stack' => [
      'driver' => 'stack',
      'channels' => ['syslog', 'slack'],
  ],

  'syslog' => [
      'driver' => 'syslog',
      'level' => 'debug',
  ],

  'slack' => [
      'driver' => 'slack',
      'url' => env('LOG_SLACK_WEBHOOK_URL'),
      'username' => 'Laravel Log',
      'emoji' => ':boom:',
      'level' => 'critical',
  ],
],
```

The `stack` driver allows you to combine multiple channels, in this case, `syslog` and `slack`, into a single log channel as shown above.

Furthermore, with the `tap` array on a channel's configuration, you can easily customize Monolog for an existing channel like so:

```php
'single' => [
    'driver' => 'single',
    'tap' => [App\Logging\CustomizeFormatter::class],
    'path' => storage_path('logs/laravel.log'),
    'level' => 'debug',
],
```

**Note:** Monolog is a library that sends your application logs to files, sockets, inboxes, databases and various web services. It's a comprehensive library with various log handlers.

Check out more [information on Logging in Laravel 5.6](https://laravel.com/docs/5.6/logging).

### 5. Single Server Task Scheduling

Before now, if your app ran on multiple servers and the task scheduler was active on those servers, then your scheduled tasks also executed multiple times. However, in Laravel 5.6, you can now schedule your task to execute on just a single server if your app runs on multiple servers.

<include src="TweetQuote" quoteText=" In Laravel 5.6, you can now schedule your task to execute on just a single server if your app runs on multiple servers."/>

```php
$schedule->command('launch:flasheavy')
         ->tuesdays()
         ->at('12:00')
         ->onOneServer();
```

### 6. Beautiful Error Reporting With Collision

[Collision](https://github.com/nunomaduro/collision) is an awesome package developed and maintained by [Nuno Maduro](https://twitter.com/enunomaduro). It is a detailed, beautiful and intuitive error handler for console/command-line PHP applications.

Laravel 5.6 now ships with Collision via the `dev` composer dependency. When working with your Laravel app via the command line, Collision provides an awesome error reporting interface like so:

![Collision Integration](https://images.ctfassets.net/23aumh6u8s0i/5WAEpSxPY66GW98BjUjqKT/8ef48bc254ac36c22540813347e7d23e/collision)
_Collision Integration with Laravel 5.6_

### 7. Elevated Eloquent Date Formatting

Laravel 5.6 provides a subtle way to cast Eloquent date model attributes to a specific date format. All you need to do is to specify the desired date format in the `$casts` array.

<include src="TweetQuote" quoteText="Laravel 5.6 provides a subtle way to cast Eloquent date model attributes to a specific date format."/>

Now, you can customize the date model attributes like so:

```php
protected $casts = [
  'date_enrolled' => 'date:Y-m-d',
  'date_evicted' => 'datetime:Y-m-d H:00',
];
```

When the model is cast to JSON or array output, the attributes will be formatted to the date formats example provided above like so:

```bash
date_enrolled: 2005-02-19
date_evicted: 2018-02-20 8:30
```

### 8. Aliasing Blade Components For Easier Access

This feature is very handy. Accessing a blade component in a sub-directory is easier via aliasing. With the component method, you can alias `components.card` to `card` assuming the card component's directory is `resources/views/components/card.blade.php`.

```php
Blade::component('components.card', 'card');
```

Once it has been aliased, you can invoke the component like so:

```php
@card
  This is your Valentine card.
@card
```

### 9. Broadcasting Channel Classes

In Laravel 5.6, you can now generate broadcasting channel classes via the `make:channel` Artisan command. The generated channel class will be placed in the `App/Broadcasting` directory.

```bash
php artisan make:channel PurchaseChannel
```

Registering the channel is as easy as calling the `Broadcast::channel` method below in the `routes/channel.php` file:

```bash
use App\Broadcasting\PurchaseChannel;

Broadcast::channel('purchase.{purchase}', PurchaseChannel::class);
```

In the `PurchaseChannel` class, you can add the authorization logic in the `join` method. Before now, the authorization logic was placed in the channel authorization Closure.

```php
<?php

namespace App\Broadcasting;

use App\User;
use App\Purchase;

class PurchaseChannel
{

  ....

  /**
   * Authenticate the user's access to the channel.
   *
   * @param  \App\User  $user
   * @param  \App\Purchase $purchase
   * @return array|bool
   */
  public function join(User $user, Purchase $purchase)
  {
      return $user->id === $purchase->user_id;
  }
}
```
### 10. Daring Upgrade Of Symfony Components and Bootstrap

All the Symfony components used by Laravel 5.6 have been bumped to the `~4.0` release. Furthermore, all the front-end scaffolding of Laravel 5.6 and Spark 6.0 has been bumped to `v4`.

I covered all the [major additions and deprecations of Bootstrap 4 in this article](https://auth0.com/blog/whats-new-in-bootstrap4).

## Deprecations and Other Updates

* Generating an API resource controller can now be done by using the `--api` switch when executing the `make:controller` command.
* Laravel 5.6 introduced helper methods, `Arr::wrap()`, `classes_uses_recursive()`, `Str::uuid()`, and `Str::orderedUuid()`, the latter generating a timestamp first UUID that's more easily and efficiently indexed by databases like MySQL.
* PHPUnit, upgraded to v7.
* Laravel Mix, upgraded to v2.
* The deprecated Artisan `optimize` command has been removed.
* Added support for customizing the mail message building in `ResetPassword::toMail()`.
* Add `policies()` method to `AuthServiceProvider` to retrieve all the policies defined by the provider.
* Two new blade directives have been added to the framework, `@csrf` and `@method`.
* Support for PostgreSQL comments was added. Furthermore, Laravel 5.6 now has better support for enumeration columns.

Check out other [Laravel 5.6 updates here](https://github.com/laravel/framework/releases/tag/v5.6.0).

## Upgrading to Laravel 5.6

Laravel 5.6 requires `PHP >= 7.1.3`. And the estimated upgrade time from Laravel `v5.5` is about ten to thirty minutes.

Check out this [comprehensive upgrade guide](https://laravel.com/docs/5.6/upgrade). However, if you don't want to be bothered about manually configuring and changing files for the upgrade, I recommend using [Laravel Shift - A service that provides automated, instant Laravel upgrade services by an army of thorough bots and friendly humans](https://laravelshift.com).

![Laravel Shift](https://images.ctfassets.net/23aumh6u8s0i/35hQnVliNvBtSA4KxrMoXL/f3d875e8dcbf6ac8bc5494c1dfd2f8f6/laravelshift)
_Laravel Shift_

<include src="asides/LaravelBackend" />

## Conclusion

**Laravel 5.6** came loaded with new features and significant improvements. Another major release will be out by August and some of the features shipping with the next major release will be unleashed at [Laracon 2018](http://laracon.us). Get your tickets already!

Have you upgraded to Laravel v5.6 yet? What are your thoughts? Let me know in the comments section! 😊


Laravel 5.6 Release: What's New?

Learn how to build your first Nette application and add authentication to it.



---

**TL;DR:** In this tutorial, I'll show you how easy it is to build a web application with Nette and add authentication to it. Check out the [repo](https://github.com/auth0-blog/nette-auth0-got) to get the code.

---

**Nette** is a free, open-source PHP framework designed for building web applications. **Nette** is a set of decoupled and reusable PHP packages that will make your work easier. And **Nette** is also known as the quick and comfortable web development framework in PHP because it has the tools that allow you to bang out PHP applications rather quickly. **Nette** has a bundle of tools that makes it one of the popular PHP frameworks out there. These tools include, **Tracy**, **Latte** and **Tester**.

* **Tracy:** is a library that helps you log errors, dump variables, observe memory consumption and measure execution time of scripts and queries. After activating Tracy on your web application, a debugger bar shows up.

  ![Tracy debug bar](https://images.ctfassets.net/23aumh6u8s0i/4ZsZRPgunjcstQ3tEA8iDu/29ab62dbd93cf686da7a9e45645a095b/tracy-bar)
  _Tracy debug bar_

This tool also provides the `Debugger::dump()` function which dumps the content of a variable far better than `var_dump`. Logging with Tracy involves invoking the `Debugger::log()` function. In production mode, Tracy automatically captures all errors and exceptions into a text log.

Another useful development magic Tracy offers is the debugger stopwatch with a precision of microseconds. Just call the `Debugger::timer()` function. For multiple measurements, you can write code like this:

```php
Debugger::timer('pdf-making');
// some code

Debugger::timer('excel-making');
// some code

$excelMakingElapsed = Debugger::timer('excel-making');
$pdfMakingElapsed = Debugger::timer('pdf-making');
```

Tracy also has an integration with [Firelogger](https://addons.mozilla.org/cs/firefox/addon/firelogger/). Learn more about how tracy works by visiting the [documentation](https://tracy.nette.org/) for more information.

* **Latte:** is a template engine for PHP. It has intuitive syntax and compiles templates to plain optimized PHP code.

``` html  

<ul n:if="$items">
{foreach $items as $item}
    <li id="item-{$iterator->counter}">{$item|capitalize}</li>
{/foreach}
</ul>

```

The best way to install Latte is via composer.

```bash
composer require latte/latte
```

And activate it by invoking it like:

```php
$latte = new Latte\Engine;

$latte->setTempDirectory('/path/to/tempdir');

$parameters['items'] = ['one', 'two', 'three'];

// render to output
$latte->render('template.latte', $parameters);
// or render to string
$html = $latte->renderToString('template.latte', $parameters);
```

Latte has a set of standard filters. You can call a filter by using the pipe symbol. Check out the code below:

``` html  

<h1>{$heading|upper}</h1>
<h1>{$heading|lower|capitalize}</h1>
<h1>{$heading|truncate:20,''}</h1>

```

You can add a custom filter by calling the `addFilter` function on Latte:

```php
$latte = new Latte\Engine;

$latte->addFilter('clear', function ($str) {
    return trim($str, 'Sd'); // eliminates Sd from the string
});
```

Then we can use it in a template like this:

``` html  

<p>{$sentence|clear}</p>

```

Learn more about how Latte works by visiting the [documentation](https://latte.nette.org) for more information.

* **Tester:** is a productive and enjoyable unit testing framework developed by the Nette team. It is used by the Nette framework for testing. It offers lots of Assertion helpers and annotations for TestCase methods. Learn more about how Tester works by visiting the [documentation](https://tester.nette.org) for more information.

**Nette**  has a [collection of plugins and extensions](https://componette.com) for easy use in your application. It also has an [active community](https://forum.nette.org).

We'll be building a simple character listing app with **Nette**. Our app will simply list **10 Game of Thrones characters** and their real names. Once we add authentication to the app, all logged-in users will have the privilege of knowing their names. Non logged-in users won't have access to any data.

**Note:** Check out how we built this small secure app with [Laravel](https://auth0.com/blog/creating-your-first-laravel-app-and-adding-authentication/).

## Let's get started

Nette utilizes [Composer](http://getcomposer.org/) to manage its dependencies. So, before using Nette, make sure you have Composer installed on your machine. We can install Nette by issuing the Composer `create-project` command in your terminal like so: `composer create-project nette/web-project GOT`.

If you are developing on a Mac OS X or Linux, you need to configure write privileges to the web server by doing `cd GOT && chmod -R a+rw temp log`.

## Explore Directory Structure

The app directory is the **bulk** of your Nette application. It contains the following directories:

![Nette Directory Structure](https://images.ctfassets.net/23aumh6u8s0i/4qYaIjWgKAfhTKlJsk6FuO/bceae2ca6be74843bde0dac7f81cbc09/nettedirectorystructure)

  * `config` - Contains all your configuration files such as database connection, session expiry time, etc.
  * `presenters` - Contains all your presenter classes and templates
  * `router` - Contains configuration for your app URLs.

The other directories namely:

  * `log` contains your app log files. You can get all the error message logs here.
  * `temp` contains your app's temporary files such as cache and session files.
  * `vendor` contains your app dependencies.
  * `www` is the only directory accessible from the web. It is supposed to store publicly available files such as images, javascript and css files.


## Setting Up The Controller

In Nette, the presenters are the controllers. They connect the models and the views. We already have the _HomePagePresenter_. Let's use it.

Open up `app/presents/HomepagePresenter.php` and configure it like so:

```php
<?php

namespace App\Presenters;

use Nette;

class HomepagePresenter extends Nette\Application\UI\Presenter
{

  public function renderDefault() {

    $characters = [
         'Daenerys Targaryen' => 'Emilia Clarke',
         'Jon Snow'           => 'Kit Harington',
         'Arya Stark'         => 'Maisie Williams',
         'Melisandre'         => 'Carice van Houten',
         'Khal Drogo'         => 'Jason Momoa',
         'Tyrion Lannister'   => 'Peter Dinklage',
         'Ramsay Bolton'      => 'Iwan Rheon',
         'Petyr Baelish'      => 'Aidan Gillen',
         'Brienne of Tarth'   => 'Gwendoline Christie',
         'Lord Varys'         => 'Conleth Hill'
    ];

    $this->template->characters = $characters;
  }
}
```

`renderDefault()` means we are going to render what we have defined in the function above in a view called `default.latte`.

`$this->template->characters = $characters` indicates that we are passing the `$characters` array variable to the `default.latte` view.

## Setting Up The View

Views are present in the `app/presenters/templates` directory. Our presenter is `HomepagePresenter`. This simply indicates that our default view is in the `app/presenters/templates/Homepage` directory.

Nette follows convention. Presenter templates can be found in `app/presenters/templates/{PresenterName}/{viewName}.latte`.

Open up `app/presenters/templates/Homepage/default.latte` and modify it to look like this:

```html

{block content}
    <h1 n:block="title"></h1>

    <div class="container">
      <div class="row">
          <div class="col-md-10 col-md-offset-1">
              <div class="panel panel-success">
                  <div class="panel-heading">List of Game of Thrones Characters</div>
                    <table class="table">
                        <tr>
                            <th>Character</th>
                            <th>Real Name</th>
                        </tr>
                        {foreach $characters as $key => $value}
                          <tr>
                            <td>{$key}</td><td>{$value}</td>
                          </tr>
                        {/foreach}
                    </table>
              </div>
          </div>
      </div>
    </div>
{/block}

```

By default, the layout template is located in `app/presenters/templates/@layout.latte`. It contains the format for presenting data in the templates.

```bash
{include content}
```

The code above inserts a block named `content` into the main template.

```bash
{block content}
```

You can then place items within the content block which is what we did in our default view.

Just before checking it out, head over to `app/presenters/templates/@layout.latte` and add the link to bootstrap within the head tag like this:

```bash
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
```

The `$characters` array variable passed from the presenter was injected into the default view. And we iterated through it to display the Game of thrones characters.

Head over to your terminal, make sure you are in the `GOT` root directory and ensure you configure write privileges to the web server if you are working on a Mac OS X or Linux system by running this command:

```bash
chmod -R a+rw temp log
```

Now, run the application:

```bash
php -S localhost:8000 -t www
```

Your application should look like this:

![Homepage](https://images.ctfassets.net/23aumh6u8s0i/2Bwf2lKEJWzkr3jIvBeV6S/56606e98a6010ec5cd089f1ef5a53686/homepage)
_Homepage_

![Tracy debug bar - Homepage](https://images.ctfassets.net/23aumh6u8s0i/6rBOyacFImxyFWIPAiLQGX/d38c9aa9e7ac1cb992ee316a61e7d87d/tracydisplay)
_Tracy in action_

![Tracy debug bar - System Info](https://images.ctfassets.net/23aumh6u8s0i/4JWn2p8zjVmnx5lWZnNSZg/e21ebdf7b5e9c998f90c32ea93b2c66d/displaysysteminfo)

Check out Tracy in action. Very easy to know the memory consumption stats and execution time.

## Setting Up Authentication With Auth0

**Auth0** issues [JSON Web Tokens](https://jwt.io/) on every login for your users. This means that you can have a solid [identity infrastructure](https://auth0.com/docs/identityproviders), including [single sign-on](https://auth0.com/docs/sso/single-sign-on), user management, support for social identity providers (Facebook, Github, Twitter, etc.), enterprise identity providers (Active Directory, LDAP, SAML, etc.) and your own database of users with just a few lines of code.

We can easily set up authentication in our Nette apps by using Auth0. If you don't already have an Auth0 account, <a href="https://auth0.com/signup" data-amp-replace="CLIENT_ID" data-amp-addparams="anonId=CLIENT_ID(cid-scope-cookie-fallback-name)">sign up</a> for one now.

> Auth0 provides the simplest and easiest to use [user interface tools to help administrators manage user identities](https://auth0.com/user-management) including password resets, creating and provisioning, blocking and deleting users. [A generous **free tier**](https://auth0.com/pricing) is offered so you can get started with modern authentication.

* Navigate to the Auth0 [management dashboard](https://manage.auth0.com/).
* Create a new client and select the type of app as `Regular Web Applications`.

    ![Create a new client](https://images.ctfassets.net/23aumh6u8s0i/EGuQhubUfSCJGsYDs55V8/6d2aadef7514f94943fd8cfde9165b72/createclient)

* Take note of the *client_id*, *domain*, and *secret*. You'll need it soon.

    ![Client details](https://images.ctfassets.net/23aumh6u8s0i/1EqdQLoj6eEabQ2EibLGVf/c5a82094b94881dc0cb556ae70cdda16/clientdetails)


### Step 1: Install and Configure Auth0 PHP package

Go ahead and install the [official Auth0 PHP Plugin](https://github.com/auth0/auth0-php) via composer.

```bash
 composer require auth0/auth0-php
```

### Step 2: Register Auth0 as a Nette Service

Head over to `app/config/config.neon` and add the following under `services:`:

```bash
auth0: Auth0\SDK\Auth0([
    'domain' : '{AUTH0_TENANT_DOMAIN}',
    'client_id' : '{AUTH0_REGULAR_WEBSITE_CLIENT_ID}',
    'client_secret' : '{AUTH0_REGULAR_WEBSITE_CLIENT_SECRET}',
    'redirect_uri' : 'http://localhost:8000/callback',
    'persist_user' : false,
    'store': false
    'debug' : true
  ])
```

We need to create a new presenter, `AuthenticationPresenter` to handle our authentication logic.

_app/presenters/AuthenticationPresenter.php_

```php
<?php

namespace App\Presenters;

use \Tracy\Debugger;
use \Nette\Http\IResponse;
use \Nette\Application\UI\Presenter;
use \Nette\Application\BadRequestException;
use \Nette\Security\AuthenticationException;

class AuthenticationPresenter extends Presenter {

  /** @var \Auth0\SDK\Auth0 @inject */
  public $auth0;

  public function actionLogin() {
    $this->auth0->login();
  }

  public function actionLogout() {
    $this->auth0->logout();
    $this->getUser()->logout();

    $this->redirect('Homepage:');
  }

  public function actionCallback($code) {
    try {
      $this->getUser()->login($code);

      $this->redirect('Homepage:');
    } catch (AuthenticationException $e) {
      Debugger::log($e, Debugger::ERROR);
      throw new ForbiddenRequestException('User not authenticated', IResponse::S403_FORBIDDEN, $e);
    }
  }

}
```

In the code above, you can see that the Auth0 service is being injected into the presenter using the `@inject` annotation. The `actionLogin` method is responsible for invoking the login function that will redirect the user to Auth0 hosted login page.

The `actionLogout` method is responsible for clearing the sessions and any Auth0 data stored in the app. It logs the user out and redirects back to the home page.

The `actionCallback` method is responsible for handling the authentication flow. When the authentication is successful from Auth0, it performs a client credential exchange and returns an authorization code.

### Step 3: Configure Auth0 Authenticator

Head over to `app/config/config.neon` and add the following under `services:`:

```bash
services:
  auth0Authenticator: App\Model\Auth0Authenticator
```

Now, create a `model/Auth0Authenticator.php` file inside the `app` directory.

Add code to the file like this:

```php
<?php

namespace App\Model;

use \Tracy\Debugger;
use \Auth0\SDK\Auth0;
use \Nette\Security\Identity;
use \Nette\Security\IIdentity;
use \Nette\Security\IAuthenticator;
use \Nette\Security\AuthenticationException;

class Auth0Authenticator implements IAuthenticator {

  /** @var \Auth0\SDK\Auth0 */
  private $auth0;

  public function __construct(Auth0 $auth0) {
    $this->auth0 = $auth0;
  }

  /**
   *  @param $args[0] Authorization Code
   *  @throws AuthenticationException
   */
  public function authenticate(array $args) : IIdentity {
    if (sizeof($args) > 0 && !empty($args[0])) {
      $code = $args[0];

      if ($this->auth0->exchange()) {
        return new Identity($this->auth0->getUser()['email'], NULL, $this->auth0->getUser());
      } else {
        throw new AuthenticationException('Auth0 code not exchanged successfully; user not authenticated.');
      }
    } else {
      throw new AuthenticationException('Auth0 code not provided; user not authenticated.');
    }
  }

}
```

This is where the credentials exchange happen, and the user info is gotten from Auth0 and injected into Nette via the Identity class.

### Step 4: Configure Routing

The default login and logout routes are `/authentication/login`, and `/authentication/logout` respectively. We'll change them to `/login` and `/logout` respectively.

Open up `app/router/RouterFactory.php` and add the following routes:

```php
...
$router[] = new Route('login', 'Authentication:login');
$router[] = new Route('logout', 'Authentication:logout');
$router[] = new Route('callback', 'Authentication:callback');
$router[] = new Route('<presenter>/<action>[/<id>]', 'Homepage:default');
```

We also added the `callback` route.

**Note:** Head over to your Auth0 client and configure the callback route in **Allowed Callback URLs**.

![Add Callback Route](https://images.ctfassets.net/23aumh6u8s0i/1gTpagCIQWaDpcG96PyBT6/2026f99416c0e2805383325354c18477/callback)
_Add Callback Route_

### Step 5: Configure The View

Head over to `app/presenters/templates/Homepage/default.latte` and replace everything with the code below:


```html

{block content}
    <h1 n:block="title"></h1>

    <div class="container">
      <div class="row">
          <div class="col-md-10 col-md-offset-1">
            {if $user->isLoggedIn()}
            <div class="panel panel-info">
              <div class="panel-heading">You are now logged in, {$user->getIdentity()->nickname} </div>
            </div>
            {/if}
            <div class="panel panel-success">
              <div class="panel-heading">List of Game of Thrones Characters</div>
              {if $user->isLoggedIn()}
                <table class="table">
                    <tr>
                        <th>Character</th>
                        <th>Real Name</th>
                    </tr>
                    {foreach $characters as $key => $value}
                      <tr>
                        <td>{$key}</td><td>{$value}</td>
                      </tr>
                    {/foreach}
                </table>
              {/if}
            </div>
            {if !$user->isLoggedIn()}
              <a href="{link Authentication:login}" class="btn btn-info"> You need to login to see the list 😜😜 >></a>
            {/if}
            {if $user->isLoggedIn()}
              <a href="{link Authentication:logout}" class="btn btn-info"> Logout >></a>
            {/if}
          </div>
      </div>
    </div>
{/block}

```

In the code above, we have some variables and function call:

* `$user->isLoggedIn()`: The `$user` variable is an [object](https://api.nette.org/2.4/Nette.Security.User.html) that is injected into the templates by default from Nette presenters and components. It represents the user. There are methods that can be called on it such as `isLoggedIn`, `login`, `logout`, etc. Here, we use to determine if the user is logged in or not.
* `$user->getIdentity()->nickname`: The `$user->getIdentity()` function call is used to get the identity of the user. Identity represents a set of user information, as returned by the authenticator in use. In our app, we used a custom authenticator, _auth0Authenticator_. And that gives us the full range of [user information](https://auth0.com/docs/user-profile) that Auth0 returns. Therefore, we can access every Auth0 user attribute like so:

```bash
$user->getIdentity()->nickname // returns user name
$user->getIdentity()->email // returns user email
```

**Note:** Check out [Nette's Access control](https://doc.nette.org/en/2.4/access-control) for a deeper understanding of how the user object works.

### Step 6: Run Your App

Now that everything is in place, go ahead and run your app.

![Homepage](https://images.ctfassets.net/23aumh6u8s0i/10SlRXpsOLBJ6BZ2sMtPzh/739978bdb07fef42020a72476877b368/start)
_Homepage_

![About to Login](https://images.ctfassets.net/23aumh6u8s0i/4r7VkEdMX5GdGQjCgIDBCo/a779cef99aee75022b3ec0b596a686e6/hostedlogin)
_Auth0 Hosted Login_

![LoggedIn](https://images.ctfassets.net/23aumh6u8s0i/9QZfCYYmTRwmnuK3UZWIg/0b3a5e15cf27ac924b822d28e448ec56/loggedin)
_User is logged in_

## Wrapping Up

Well done! You have just built your first app with Nette. It focuses on simplicity, clarity and getting work done. As we saw in this tutorial, you can easily add authentication to your Nette apps.

This tutorial is designed to help you get started on building and adding authentication to your own apps with the Nette framework. You can leverage the knowledge gained here to build bigger and better apps.

Please, let me know if you have any questions or observations in the comment section. 😊


Building an app with Nette and adding authentication

Learn how to quickly build apps with BackboneJS.

BackboneJS: Getting Started

Learn how to build and secure your first CakePHP app.

Creating and securing your first CakePHP app

Learn how to quickly build ambitious apps with EmberJS 2 and add authentication the right way.

EmberJS Authentication Tutorial

Learn how to build your first AdonisJs application and add authentication to it.

Creating your first app with AdonisJs and adding authentication

001c9ddc5ceb9829b6aaf24f5d28502a

I am software developer with a keen interest in open-source technologies, Linux, and native development. I've worked on many different platforms Android, iOS, Win32, Linux, FreeRTOS, the Web, and others. I've gone through the whole stack and I enjoy learning and using the latest technologies. I now work as a full-stack developer at Auth0.

Senior Engineer

Sebastian Peyrott

Are you following these tips? If not, learn how to create a faster web app!

"web-app"