First of all, we have to create a database, and define the connection information to Laravel. To do this, we open the database.php file under app/config, and then fill the required credentials. Laravel supports MySQL, SQLite, PostgreSQL, and SQLSRV (Microsoft SQL Server) by default. For this tutorial, we will be using MySQL.

We will have to create a MySQL database. To do this, open your MySQL console (or phpMyAdmin), and write down the following query:

CREATE DATABASE urls

The previous command will generate a new MySQL database named urls for us. After having successfully generated the database, we will be defining the database credentials. To do this, open your database.php file under app/config. In that file, you will see multiple arrays being returned with database definitions.

The default key defines what database driver to be used, and each database driver key holds individual credentials. We just need to fill the one that we will be using. In our case, I've made sure that the default key's value is mysql. To set the connection credentials, we will be filling the value of the mysql key with our database name, username, and password. In our case, since we have a database named urls, with the username as root and without a password, our mysql connection settings in the database.php file will be as follows:

'mysql' => array(
  'driver' => 'mysql',
  'host' => 'localhost',
  'database' => 'database',
  'username' => 'root',
  'password' => '',
  'charset' => 'utf8',
  'collation' => 'utf8_unicode_ci',
  'prefix' => '',
),

Now, we will be using the Artisan CLI to create migrations. Artisan is a command-line interface specially made for Laravel. It provides numerous helpful commands to help us in development. We'll be using the following migrate:make command to create a migration on Artisan:

php artisan migrate:make create_links_table --table=links --create

The command has two parts:

As you can see, unlike Laravel 3, when you run the previous command, it will create both the migrations table and our migration. You can access the migration file under app/database/migrations, having the following code:

<?php
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateLinksTable extends Migration {
  /**
  * Run the migrations.
  *
  * @return void
  */
  public function up()
  {
    Schema::create('links', function(Blueprint $table)
    {
      $table->increments('id');
    });
  }
  /**
  * Reverse the migrations.
  *
  * @return void
  */
  public function down()
  {
    Schema::drop('links');
  }
}

Let's inspect the sample migration file. There are two public functions which are declared as up() and down(). When you execute the following migrate command, the contents of the up() function will be executed:

php artsian migrate

This command will execute all of the migrations and create the links table in our case.

We can also roll back to the last migration, like it was never executed in the first place. We can do this by using the following command:

php artisan migrate:rollback

In some cases, we may also want to roll back all migrations we have created. This can be done with the following command:

php artisan migrate:reset

While in the development stages, we may forget to add/remove some fields, or even forget to create some tables, and we may want to roll back everything and remigrate them all. This can be done using the following command:

php artisan migrate:refresh

Now, let's add our fields. We've created two additional fields called url and hash. The url field will hold the actual URL, to which the URL present in the hash field will be redirected. The hash field will hold the shortened version of the URL that is present in the url field. The final content of the migration file is as shown in the following code:

<?php
use Illuminate\Database\Migrations\Migration;
class CreateLinksTable extends Migration {
  /**
  * Run the migrations.
  *
  * @return void
  */
  public function up()
  {
    Schema::create('links', function(Blueprint $table)
    {
      $table->increments('id');
      $table->text('url');
      $table->string('hash',400);
    });
  }
  /**
  * Reverse the migrations.
  *
  * @return void
  */
  public function down()
  {
    Schema::drop('links');
  }
}

Save the following code as form.blade.php under app/views. The file's extension is blade.php because we will be benefiting from Laravel 4's built-in template engine called Blade . There may be some methods you don't understand in the form yet, but don't worry. We will cover everything regarding this form in this chapter.

<!DOCTYPE html>
<html lang="en">
  <head>
    <title>URL Shortener</title>
    <link rel="stylesheet" href="/assets/css/styles.css" />
  </head>
  <body>
    <div id="container">
      <h2>Uber-Shortener</h2>
      {{Form::open(array('url'=>'/','method'=>'post'))}}

      {{Form::text('link',Input::old('link'),array('placeholder'=>'Insert your URL here and press enter!'))}}
      {{Form::close()}}
    </div>
  </body>
</html>

Now save the following codes as styles.css under public/assets/css:

div#container{padding-top:100px;
  text-align:center;
  width:75%;
  margin:auto;
  border-radius:4px}
div#container h2{font-family:Arial,sans-serif;
  font-size:28px;
  color:#555}
div#container h3{font-family:Arial,sans-serif;
  font-size:28px}
div#container h3.error{color:#a00}
div#container h3.success{color:#0a0}
div#container input{display:block;
  width:90%;
  float:left;
  font-size:24px;
  border-radius:5px}
div#error,div#success{border-radius:3px;
  display:block;
  width:90%;
  padding:10px}
div#error{background:#ff8080;
  border:1px solid red}
div#success{background:#80ff80;
  border:1px solid #0f0}

This code will produce you a form that looks like the following screenshot:

As you can see, we have used a CSS file to tidy up the form a bit, but the actual part of the form is at the bottom of the View file, inside div with the ID of the container.

We have used the Laravel's built-in Form class to generate a form, and we have used the old() method of the Input library. Now let's dig the code:

Checking whether the link is already in our database.

If the link is already in our database, returning the shortened link.

If the link is not present in our database, creating a new random string (the hash that will be in our URL) for the link.

Creating a new record in our database with the provided values.

Returning the shortened link back to the user.

Here's the first part of our code:

// Now let's check if we already have the link in our database. If so, we get the first result
$link = Link::where('url','=',Input::get('link'))
->first();

First, we check if the URL is already present in our database using the where() method of Fluent Query Builder , and get the first result via the method first(), and assign it to the $link variable. You can use the Fluent query methods along with the Eloquent ORM easily. If this confuses you, don't worry, we will cover this further in the later chapters.

This is the next part of our controller method's code:

//If we have the URL saved in our database already, we provide that information back to view.
if($link) {
  return Redirect::to('/')
  ->withInput()
  ->with('link',$link->hash);

If we have the URL saved in our database, the $link variable will hold the object of our link's information taken from the database. So with a simple if() clause, we can check if there is a result. If there is a result returned, we can access it using $link->columnname.

In our case, if the query has a result, we redirect the inputs and the link back to the form. As we've used here, the with() method can also be used with two parameters instead of using a camel case—withName('value') is exactly the same as with('name','value'). So, we can return the hash code with a flash data named link with('link',$link->hash). To show this, we can add the following code to our form:

@if(Session::has('link'))
<h3 class="success">
  {{Html::link(Session::get('link'),'Click here for your shortened URL')}}</h3>
@endif

The Html class helps us write HTML codes easily. The link() method requires the following two parameters:

The optional third parameter has to be an array, holding attributes (such as class, ID, and target) as a two-dimensional array.

The following is the next part of our code:

//Else we create a new unique URL
} else {
  //First we create a new unique Hash
  do {
    $newHash = Str::random(6);
  } while(Link::where('hash','=',$newHash)->count() > 0);

If there is no result (the else clause of the variable), we are creating a six-character-long alphanumeric random string with the Str class's random() method and checking it each time to make sure that it is a unique string, using PHP's own do-while statement. For real world application, you can use an alternative method to shorten, for example, converting an entry in the ID column to base_62 and using it as a hash value. This way, the URL would be cleaner, and it's always a better practice.

This is the next part of our code:

//Now we create a new database record
Link::create(array(
  'url' => Input::get('link'),
  'hash' => $newHash
));

Once we have a unique hash, we can add the link and the hash values to the database with the create() method of the Laravel's Eloquent ORM. The only parameter should be a two-dimensional array, in which the keys of the array are holding the database column names, and the values of the array are holding the values to be inserted as a new row.

In our case, the url column has to have the link field's value that came from the form. We can catch these values that came from the post request using Laravel's Input class's get() method. In our case, we can catch the value of the link form field that came from the post request (which we would catch using the spaghetti code $_POST['link']) using Input::get('link'), and return the hash value to the view as we did earlier.

This is the final part of our code:

//And then we return the new shortened URL info to our action return Redirect::to('/')
->withInput()
->with('link',$newHash);

Now, at the output, we're redirected to oursite.dev/hashcode. There is a link stored in the variable $newHash; we need to catch this hash code and query our database, and if there is a record, we need to redirect to the actual URL.

In the Route class, we first make a search query, as we did in the earlier section, and check if we have a link with the given hash from a URL in our database, and set it to a variable called $link.

//First we check if the hash is from an URL from our database
$link = Link::where('hash','=',$hash)
->first();

If there is a result, we redirect the page to the url column of our database, which has the link to which the user should be redirected.

//If found, we redirect to the link
if($link) {
  return Redirect::to($link->url);
}

If there is no result, we redirect the user back to our index page using the $message variable, which holds the value Invalid Link.

//If not found, we redirect to index page with error message
} else {
  return Redirect::to('/')
  ->with('message','Invalid Link');
}

To show the Invalid Link message in the form, add the following code in your form.blade.php file placed under app/views:

@if(Session::has('message'))
<h3 class="error">{{Session::get('message')}}</h3>
@endif