So I was working away on a website when a support ticket landed on the helpdesk. It was a client complaining that her products on her Magento 2 website had ALL been marked as out of stock. You could sense the panic from the client. During a busy period where stock is selling, this problem just cropped up from out of nowhere.

Magento Index Management

Below is a brief description of what index management is and what this does on the website. This is a snippet taken from the Magento User Guide found here;

Magento reindexes automatically whenever one or more items change. Actions that trigger reindexing include price changes, creating catalog or shopping cart price rules, adding new categories, and so on. To optimize performance, Magento accumulates data into special tables using indexers. As the data changes, the indexed tables must be updated — or reindexed. Reindexing is performed as a background process, and your store remains accessible during the processes.

So you can see just how important it is for the indexers to be working on the Magento website. If the indexer is not updating stock levels or price rules, it could result in products being sold at the wrong advertised price, some new products not appearing, categories not showing up. Make sure that all the indexer statuses are appearing in green. Below is an example of the indexers appearing fine.

What steps did you take next?

At this point I was left scratching my head, thinking what to do next. The client was manually updating the stock statuses, something that would have taken an age even if there were several people working on the site at one time. My first thought was to run the clean and flush cache commands via SSH.

Here are the commands that were used via SSH;

php bin/magento cache:clean
php bin/magento cache:flush

Simple enough right? Not quite! Now at this point, even I started panicking a little. I’m the one that should be calm through this. I guess that wasn’t the case!

Then I decided to run the indexer command, I was confident that this would resolve the problem the client was having with the stock statuses showing as “Out of stock”

php bin/magento indexer:reindex

So did that resolve the problem, panic over?

Nope, that did not resolve the problem for the client. At this point, I was scratching my head even harder, any more head-scratching and I’d end up going bald. I kicked the panic to one side, took a deep breath & said to myself that I’m going to resolve this problem before I do anything else.

I came across a command that I didn’t see when looking at the documentation for Magento 2 — I know the commands to clear the cache and flush it from the top of my head, publishing content is fine, running the indexer no problem, but this one command slipped through the net for me. This was the command that would save the hair on my head and kill off the panic for the client.

php bin/magento indexer:reset

Oh, you beauty! Running the command in my terminal and flushing the cache sorted this issue out. Turned out that the status column under Index Management was showing as “Processing” for some of the indexers. This is definitely one command I won’t ever forget. It’s etched in my brain now.

I hope this experience will come in handy for someone that may be in the same situation that I was in. Now I can’t guarantee that the problem I came across will be the same one you’ll experience.

I need a coffee now. Phew. Is anyone willing to brew up for me?

WordPress is one of the most used Content Management Systems (CMS) out there. Some may argue that it’s a blogging platform, some may argue that it’s more than that. I guess we’ll never come to one agreement on what WordPress really is. All I know is that it’s a brilliant platform to learn & develop on.

I develop quite a few websites in WordPress. It’s open-source and free to use. It comes with a repository of plugins that you can install on WordPress to extend its functionality and do cool stuff. What isn't there to like about that?

Advanced Custom Fields PRO (ACF Pro)

ACF Pro has to be my favourite plugin for WordPress of all time. This allows you to quickly add meta fields, fields to a post, custom post type, post template etc. It’s ideal for custom-built themes in WordPress. You can’t go wrong with this plugin. Not only is this a great plugin to use, but the documentation is also well written, straightforward and understandable, no matter what programming experience you have.

They offer a free version of the plugin which covers most of your needs, but having the PRO version means having those additional fields you can integrate into your WordPress project. Constant updates are also made to the plugin to keep up with the latest changes made by WordPress.

Yoast SEO

One of the most used plugins on WordPress for search engine optimisation (SEO) is Yoast, there is a premium and free version available. We all want to optimise our website so search engines are able to access it. We all aim to have our websites appear as high as possible in search rankings so it’s more accessible. This is another plugin that provides constant updates on both plans. The UI is fairly simple to use, so for any beginners, you can crack on with optimising pages without the help of an expert.

Yep, Yoast SEO Premium makes it really easy to seduce search engines. In the free version, you can only set 1 focus keyword. That means you’ll have to choose between keywords. In both versions, Yoast SEO doesn’t only help you boost your ranking in the search results, but also your morale!

What’s good about the plugin is that it has a built-in preview of what the page will look like once you’ve optimised the description and added keywords. However, most recently I’ve come across another SEO plugin called The SEO Framework. A lightweight plugin that just has the same effect as Yoast SEO.

Monster Insights

This is another plugin that I use on all WordPress websites. It allows you to enter the Google Analytics tracking code within WordPress which then places the script in the correct part of the website so you can start tracking activity on your website. After all, we all want to know where our users come from, which part of the website they are accessing and how long they are active.

MonsterInsights is Trusted by Over 1 Million Businesses Worldwide.

Not only does this Monster Insights allow you to add analytics to the website, it has a built-in dashboard, once approved with your account it shows you stats, just like the Google Analytics dashboard. You can now stop logging into GA to view stats, log into your website instead and see all the information in there.

Wordfence Security

Security is essential — we now live in a world where security is a must. With WordPress being targeted by malicious hackers you need some sort of security in place to combat the attacks that take place on a daily basis. Not having the correct security for your website can be catastrophic. Below are some points on what could happen if there is no security on your website;

• Website hacked/defaced
• Database compromised
• Malware infecting the website
• Stealing credit card information

Wordfence Security can combat this for you. They offer premium and free versions. While the free version is more than good enough, you can opt to go premium depending on your security needs.

Wordfence usability is straightforward and very easy to configure. Within a few clicks, you can have Wordfence scanning the website periodically looking for any vulnerabilities or malware. It also allows you to do the following;

• Web Application Firewall
• Real-Time Threat Defense Feed (Premium)
• Block Brute Force Attacks
• Country Blocking (Premium)
• Advanced Manual Blocking
• Malware Scanner

So you can see you have a vast amount of features available to you. You can also set login notifications, so whenever someone accesses the website you are alerted of this so. It also notifies you of any plugins that are outdated and may need updating. Any files that have been changed will also be picked up. I’ve not had a problem ever using this plugin before. It definitely puts my mind at ease knowing the website is monitored and secure.

EWWW Image Optimisation

Optimising images is a big part of search engine optimisation. It’s really important that images load up quickly on a website no matter where it is accessed from, being a mobile phone or desktop computer. Sites that take more than 3–4 seconds to load will result in the person clicking off your website.

Here are a few of the features EWWW offer;

• Faster Images
• High-Quality Compression
• Personal Support
• Free Image Backups

If you are showcasing products on a website, it’s important that they load as quick as possible, you don’t want potential customers waiting a few minutes for an image to load. This is where EWWW comes into effect.

Over 600k Sites Use EWWW IO to Speed Up Their Images

The need for speed is great. Within a few clicks, you can bulk optimise loads of images that have been uploaded to WordPress and this runs in the background for you. Not long ago, I rebuilt a website for a client that was on WordPress which contained loads of high-resolution images that were not optimised. This affected his page speed load times and the drop off rate was quite high.

The main reason for this was that there were images over 1MB each which was bogging down the website. Running the optimiser worked wonders — not only did the client have optimised images, but the speed of his website was quicker. The page speed was reduced drastically.

WP Fastest Cache

With over 6 million downloads and counting, WP Fastest Cache is one of the go-to plugins for increasing the speed of a website. A host of features are available to you with this plugin, both free and premium.

• Desktop Cache
• Mobile Cache
• Widget Cache
• Minify HTML
• Minify HTML Plus
• Minify CSS
• Minify CSS Plus
• Combine CSS
• Minify JS
• Combine JS
• Combine JS Plus
• Render Blocking JS
• GZIP
• Browser Caching
• Image Optimization
• Cache Statics
• Delete Cache Logs
• Database Cleanup
• Google Fonts Async

If you are not a developer then with a few clicks you can optimise the website and increase the Page Speed dramatically without the need of tinkering with the htaccess file. However you could experience problems based on the theme you are using, if it’s been built quite bad and not followed the WordPress standards then you’ll have a more difficult experience in speeding up the website.

Redirection

Another one of my favourite plugins — Redirection. I definitely dislike doing 301 redirects all manually in the htaccess file. With this plugin you can easily create the redirects, manage them with a nice interface and look after any 404 errors you get on the website.

Most of all, it’s free, yes, completely free. This is very useful for someone that has a redeveloped website on a new/existing platform and the URL structure differs. We can keep the old links alive by setting up 301 redirects that direct the user to the new URL all without them knowing that the URL has changed unless they look at the address bar!

There are more plugins, wait, did you say more?

Yes, there is more. I could sit here all day and list all the plugins that I recommend, but that would put you to sleep. I’ve just touched upon some of the plugins that I use when it comes to WordPress. Let me know what plugins you install on WordPress and why?

In order to connect a database, we will concentrate on the .env file. This is where you will find the configuration settings to set the database host, username and password along with a host of configurations. You may never end up using all of them. Below is an example of the .env file that is generated when you create a new Laravel project.

APP\_NAME=Laravel

APP\_ENV=local

APP\_KEY=base64:7b6e1+2Ok25kR2g54fVFeEWfXciimtt5eAvBSK7RpWc=

APP\_DEBUG=true

APP\_URL=http://localhost

LOG\_CHANNEL=stack

DB\_CONNECTION=mysql

DB\_HOST=127.0.0.1

DB\_PORT=3306

DB\_DATABASE=homestead

DB\_USERNAME=homestead

DB\_PASSWORD=secret

BROADCAST\_DRIVER=log

CACHE\_DRIVER=file

QUEUE\_CONNECTION=sync

SESSION\_DRIVER=file

SESSION\_LIFETIME=120

REDIS\_HOST=127.0.0.1

REDIS\_PASSWORD=null

REDIS\_PORT=6379

MAIL\_DRIVER=smtp

MAIL\_HOST=smtp.mailtrap.io

MAIL\_PORT=2525

MAIL\_USERNAME=null

MAIL\_PASSWORD=null

MAIL\_ENCRYPTION=null

PUSHER\_APP\_ID=

PUSHER\_APP\_KEY=

PUSHER\_APP\_SECRET=

PUSHER\_APP\_CLUSTER=mt1

MIX\_PUSHER\_APP\_KEY=”${PUSHER\_APP\_KEY}”

MIX\_PUSHER\_APP\_CLUSTER=”${PUSHER\_APP\_CLUSTER}”

The only part of the .env file we need to focus on is the MySQL configuration. We need to create the database using PHPMyAdmin or SQL Workbench. Then enter populate the following fields.

DB\_CONNECTION=mysql  
DB\_HOST=127.0.0.1  
DB\_PORT=3306  
DB\_DATABASE=database-name-here  
DB\_USERNAME=username-here  
DB\_PASSWORD=your-password-here

There’s also a database.php file that can be found inside the config folder. This file shows you the different database connections you can make. For now, we will use the default MySQL connection. That is good enough. You can see the file here on the official Laravel Github repository: https://github.com/laravel/laravel/blob/master/config/database.php

Database Migrations

In order to create a migration in Laravel we use the following command;

php artisan migrate

Once you run this command it will create the users & password reset tables. By default, it also creates a migration table where it’ll store every single migration you make. You should never tinker with this table.

Here are the default migration files that come with Laravel out of the box.

Let’s have a quick look at the migration file and what it’s doing once the migrate command is run in our terminal.

So in the up function, this is where the fields are specified. It’s all pretty straightforward. When we run the migrate the command, the up function is executed and the table is created inside our database. If you’ve run the migrate command successfully, head over to the database that you’ve created, give it a refresh and take a look at the tables that have been created.

As you can see, the columns have been created which reflects the user migration file.

What if we want to delete the table? Can we do this through PHPMyAdmin or Workbench? Yes, we can do that, but if there is a command for it, why not use that? We must get into the habit of using the Artisan commands that are available to us, it will save you loads of time, trust me!

php artisan migrate:reset

The above command will reset the migration for you, there is also the rollback command that rolls back the LAST migration you ran. So that is why it’s important we don’t tinker with the migrations database and the files that are created in the migrations folder. We require these.

There is another command that we can also run, but it’s very important that you only use it in the local environment and not on a live server/project.

php artisan migrate:fresh

The migrate:fresh command will drop all tables from the database and then execute the migrate command.

Creating a migration

To create a migration, we can use the make:migration command. This will create the PHP file inside our migrations folder.

php artisan make:migration create\_tasks\_table

We now have a migration file created, open up that file and let's start adding some fields to it. What I’m going to do is add a title and description field to our database. A task will have a title & a description.

Title and Description have been added to the migration file.

We now have a title and description field when we ran the migrate command.

If you want to make a change to the migration file without deleting the table, we can run the following command;

php artisan migrate:fresh

This will run ALL migrations again. You can find out more information on the Laravel documentation: https://laravel.com/docs/5.7/migrations#running-migrations

In the next article, I will show you how to insert data into the table and how we can query this in our Laravel project.

I hope you’ve enjoyed this article, give it a share. If you have any comments, feel free to use the comments section or get in touch with me on my Twitter. Don’t forget to have a look at my previous articles.

Instead of defining all of your request handling logic as Closures in route files, you may wish to organize this behavior using Controller classes. Controllers can group related request handling logic into a single class. Controllers are stored in the **app/Http/Controllers** directory.

In our routes file, we may want to add more logic to a view, this could get tiresome with loads of code showing. We want to simplify how we work, Laravel allows us to do that, we can use a dedicated controller to add more logic to our routes/views.

If you take a look at the routes file in your editor, each page is static, so what we can do is create a Pages Controller — we can simplify the code more by using the controller we are about to create.

So let’s start with the homepage route, we need to create a new line in our routes file and define the Pages Controller followed by a method/action. If your getting confused now, hang in there, this will become clearer to you shortly.

Route::get(‘/’, ‘PagesController@home’);

Comment out the code for the homepage route that has the array of tasks, reload the homepage and you should see the following error;

Oops, we’ve not created the “PagesController” — Laravel is looking for this and can’t find it, this is easy to fix. Head over to your terminal and run the following command to create the controller.

$ php artisan make:controller PagesController

What we must not do is create the controller manually, Laravel offers the boilerplate to you, it whips up the necessary code when you create the controller through the command line. Let’s get into the habit of using the terminal and running the necessary commands, the more you use the commands, the more it’ll sit in your brain for future reference.

You will find the controller inside app/http/controllers/ — this is where the controllers live in Laravel. This is what the Pages Controller looks like once it has been created;

You can see why it was much simpler to run the command to create the controller. We wouldn't want to be importing the namespace etc manually in case we need to.

Let’s create a method for home, otherwise, the PagesController will not work.

public function home() {

}

We now need to migrate the data from the old route we initially had into the method we have just created. Delete the old route for the homepage as we won’t be needing that moving forward. This is what the end result should look once you’ve migrated over the data to the method.

We can now migrate the rest of the routes over to the Pages Controller. We need to copy the same line where we called the home method and name the methods as the page name. This is to keep some consistency and quickly identify each method. Our routes file should now look something like this;

Route::get(‘/’, ‘PagesController@home’);;

Route::get(‘/about’, ‘PagesController@about’);;

Route::get(‘/contact’, ‘PagesController@contact’);

And here we have the Pages Controller with two additional methods added that return the view. If you’ve followed the steps correctly, then the homepage and the other pages should be working just like they did without the Pages Controller created.

So for any large projects that you may be working on, this is the ideal way to go about things, you may come across existing projects that follow this structure. This keeps things nicely separated.

That’s it, you now should understand how to use dedicated controllers in Laravel. In the next article, we will be looking at “Databases and Migrations”.

I hope you’ve enjoyed this article, give it a share. If you have any comments, feel free to use the comments section or get in touch with me on my Twitter. Don’t forget to have a look at my previous articles.

This article will show you how to send data to your Laravel view. So let’s get started. For example, let’s say when a user accesses the homepage, we want to send some data to it for them to view. Head over into your code editor and go to routes/web.php — this is where we will be passing in the data for now by hardcoding it in.

Inside the route get for the homepage we need to create a variable and pass in some tasks as an array. So take a look at the code below to see the tasks that have been created.

Route::get(‘/’, function () {

$tasks = \[  
    ‘Build header of the website’,  
    ‘Build footer of the website’,  
    ‘Build the homepage template’,  
\];

return view(‘welcome’);

});

If we access the homepage, nothing is going to happen in regards to the tasks data being passed through. We haven't returned this yet. Next, you need to call tasks in the return function.

return view(‘welcome’, \[  
    ‘tasks’ => $tasks  
\]);

Rendering data in the view

Remember to pass this in as an array. We’re nearly there, head over to the welcome.blade.php file and inside a foreach loop, we will render the tasks that we’ve hardcoded in.

<ul class=”tasks-list”>  
@foreach ($tasks as $task)  
    <li class=”task-item”><?= $task ?></li>  
@endforeach  
</ul>

Remember to use the blade syntax and not the standard PHP foreach loop. Either way will work, but it’s best to get accustomed to the correct syntax when using Laravel. So here we are cycling through the array of tasks that have been assigned to the $tasks variable & rendering those items into an unordered list.

Here is the outcome when you reload the homepage.

The tasks list has now been passed into the homepage view.

If you add another task to the array in the routes file, that will show up here. Fairly simple isn’t it? We can also change the way we call out the $task in the list without using the PHP shorthand syntax;

<li class=”task-item”>{{ $task }}</li>

We’ve now replaced <?= ?> with the double curly braces. I prefer this, it just looks loads cleaner and easier to read. Always look at ways to simplify the code if you can.

Passing variables in to your view

We can also pass in as many variables as we want when we are returning the tasks on the homepage view. We just need to add another line of code and then call the variable in our blade file.

return view(‘welcome’, \[  
    ‘tasks’ => $tasks,  
    ‘sitename’ => ‘Laravel’  
\]);

I’ve just created a variable called sitename for now. In the blade file, this is how I’ve called that variable.

<h1>{{ $sitename }} — Homepage</h1>

Simple and straightforward. Don’t you just love it? We can fetch anything from the query string, let me show you how to do this. We ain’t finished just yet. There’s more goodness to showcase here. Let’s create a request;

‘title’ => request(‘title’)

We now need to go back to the homepage and enter the following into the URL after the homepage URL.

http://laracasts.local/?title=Laracasts

So what happens when you pass in the word Laracasts? Below is the result of requesting something from the query string;

We’ve requested the title Laracasts and rendered that on the page.

The curly braces in Laravel escape the data and render what’s left on the page. This is brilliant, we want to make sure no malicious data is being passed through. For example, if we try passing in script tags into the variable that we have created, do you think that will render a script on the page?

‘title’ => ‘<script>alert(“Hello — I love laravel”)</script>’

The outcome is that the script was not executed as a script, whatever was passed into the variable has been stripped out.

<h1>&lt;script&gt;alert(&quot;Hello — I love laravel&quot;)&lt;/script&gt; — Homepage</h1>

And there you have it, the script has been stripped down and rendered. So you may ask, how do I make sure a script acts as a script? We can use !! exclamation points on either side of the curly braces. This is what it should look like.

<h1>{{!! $title !!}} — Homepage</h1>

If you refresh the homepage now, the script will be initialised and will successfully run.

Voila — our script alert is now working!

I’ve mentioned that we should always look at ways to simplify our code. When we are returning the tasks variable to our view, it looks a little messy to me. We can pass that data to our view with one line of code, yes, just one!

return view(‘welcome’, \[  
    ‘tasks’ => $tasks,  
    ‘title’ => request(‘title’)  
\]);

The above code is now going to be simplified into one line.

return view(‘welcome’)->withTasks($tasks)->withTitle('`Laracasts`');

We can pass in the two functions and within those pass in the variable & string. We can inline the tasks in the return function if you want to. There are different ways we can pass in the tasks.

Route::get(‘/’, function () {  
    return view(‘welcome’)->withTasks(\[  
        ‘Build header of the website’,  
        ‘Build footer of the website’,  
        ‘Build the homepage template’,  
        ‘Build the contact form’,  
    \]);  
});

I prefer this way. Whichever way works for you that’s fine, there is no right or wrong way.

Using compact() in Laravel

The function compact is widely used in Laravel, don’t confuse this with a Laravel function because it’s not, this is a PHP function. You can see more information on this over HERE. So with() allows you to pass variables to a view and compact() creates an array from existing variables given as string arguments to it.

Below is an example of how we’d use the compact function.

$user = User::all();   
return view('index', compact('user'));

Here is another example where we are passing the name into our view surrounded by HTML. This will output the name Joe Bloggs on the home view.

Route::get('/', function () {  
    return view('greeting', compact(['name' => 'Joe Bloggs']));  
});  
<html>  
    <body>  
        <h1>Hello, {{ $name }}</h1>  
    </body>  
</html>

That’s it, you now should understand how to send data to your views. In the next article, we will be looking at “Controllers”. I hope you’ve enjoyed this article, give it a share. If you have any comments, feel free to use the comments section or get in touch with me on my Twitter. Don’t forget to have a look at my previous articles.

Thank you.

CREATING A LAYOUT FILE

Head over into your code editor and go into /resources/views/ and create a new file called layout.blade.php. Remember to add the word blade into the filename, otherwise, it won’t work.

Once you’ve created the layout file, copy and paste the HTML from the welcome.blade.php view and into the layout file. The HTML that we will move over is shown below;

The HTML that has been added to the layout.blade.php file

Once you’ve done that, we need to add in the following code into the layout file;

@yield(‘content’);

Here we are telling Laravel to render the content. Go back to welcome.blade.php and delete everything that is in it. For now, we will add this bit of code in the view file.

@extends(‘layout’)

We are telling Laravel to look into the views folder and locate the layout blade file that we created, whatever is inside that file will be rendered on the homepage. I’ve added in two links, one for the homepage, the other to the about page. This is how it will show on the homepage.

If you wish to do so, you could even create a layout direct inside the views folder. If you go down this route, no pun intended, then you would have to reference the layout file using the following;

@extends(‘layouts.layout’)

Notice that we have used the ‘.’ to separate the directories. You could replace the period with a ‘/’ but I think it looks better visually with the period. For now, I’m going to keep the layout file where it is.

We now need to register a section, further up, we added the yield code into the template, but there is no section for it, so nothing will be rendered. To register a section we need to add the following to our template file;

@section(‘content’)  
   <p>This is the content.</p>  
@endsection

Refresh the homepage and it’ll show you the content you have added. Remember, we need to use the blade syntax here. For every section you create, you must remember to add @endsectionotherwise you’ll run into problems.

Remember, wherever you add the yield content snippet of code, Laravel will render the content there. So please, make sure you add it to a sensible place, for example, below the navigation and not above it.

TITLE TAGS — HOW CAN WE SET THIS?

If you take a look at the tab in your browser, you will notice that the page title is currently showing the URL. Now, that looks messy, doesn't it? It’s not really SEO friendly — so we need to get that changed. Let me show you how you can achieve this.

If you take a look at the<title></title> it’s currently empty. We need to set something here. We simply cannot go to the layout file and hardcode some text in there. Otherwise, this will display on ALL pages. It needs to be dynamic.

To get the title working, we need to add the following snippet of code;

@yield(‘title’)

We then need to create a section called title in order for this to pull the title that we will set in the view template.

@section(‘title’)  
    Home  
@endsection

It’s as easy as that. But what happens if we don’t define a section called title? If we don’t have a section, it will default back to the title, so we need to put something in place for that scenario. Take a look at the following snippet of code where we will be setting a fallback.

<title>@yield(‘title’, ‘Default Title’)</title>

We set a second value after the title using a comma. So if the section title is not defined in the view template, it will render “Default Title”. Think of it as an if-else statement.

We can simplify the title when we define the section. Have a look at this snippet of code;

@section(‘title’, ‘Home’)

That looks loads better, easier to read and we can get the code onto one line. Always look at ways to shorten the code and markup if possible. Either way is fine, I just prefer it this way.

That’s it, you now should understand how blade layout files work and how we can set a dynamic page title for our view. In the next article, we will be looking at “Sending Data to Your Views”.

I hope you’ve enjoyed this article, give it a share. If you have any comments, feel free to use the comments section or get in touch with me on my Twitter.

Thank you.

But before diving right into the deep end and drowning, let’s take a look at some of the commands that will be used. In the terminal enter the following command;

php artisan

Artisan is the built-in command into Laravel, this will give you a list of all the commands that are available to you, don’t worry though, some of the commands will make sense once you start using them. Below is a list of the commands that show up once that command has been executed.

Usage:
command [options] [arguments]

Options:
-h, — help Display this help message
-q, — quiet Do not output any message
-V, — version Display this application version
— ansi Force ANSI output
— no-ansi Disable ANSI output
-n, — no-interaction Do not ask any interactive question
— env[=ENV] The environment the command should run under
-v|vv|vvv, — verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Available commands:

clear-compiled Remove the compiled class file
down Put the application into maintenance mode
dump-server Start the dump server to collect dump information.
env Display the current framework environment
help Displays help for a command
inspire Display an inspiring quote
list Lists commands
migrate Run the database migrations
optimize Cache the framework bootstrap files
preset Swap the front-end scaffolding for the application
serve Serve the application on the PHP development server
tinker Interact with your application
up Bring the application out of maintenance mode

app app:name Set the application namespace
auth
auth:clear-resets Flush expired password reset tokens

cache cache:clear Flush the application cache
cache:forget Remove an item from the cache
cache:table Create a migration for the cache database table
config
config:cache Create a cache file for faster configuration loading
config:clear Remove the configuration cache file

db db:seed Seed the database with records

event event:generate Generate the missing events and listeners based on registration

key key:generate Set the application key

make make:auth Scaffold basic login and registration views and routes
make:channel Create a new channel class
make:command Create a new Artisan command
make:controller Create a new controller class
make:event Create a new event class
make:exception Create a new custom exception class
make:factory Create a new model factory
make:job Create a new job class
make:listener Create a new event listener class
make:mail Create a new email class
make:middleware Create a new middleware class
make:migration Create a new migration file
make:model Create a new Eloquent model class
make:notification Create a new notification class
make:observer Create a new observer class
make:policy Create a new policy class
make:provider Create a new service provider class
make:request Create a new form request class
make:resource Create a new resource
make:rule Create a new validation rule
make:seeder Create a new seeder class
make:test Create a new test class

migrate migrate:fresh Drop all tables and re-run all migrations
migrate:install Create the migration repository
migrate:refresh Reset and re-run all migrations
migrate:reset Rollback all database migrations
migrate:rollback Rollback the last database migration
migrate:status Show the status of each migration

notifications notifications:table Create a migration for the notifications table

optimize
optimize:clear Remove the cached bootstrap files

package package:discover Rebuild the cached package manifest

queue queue:failed List all of the failed queue jobs
queue:failed-table Create a migration for the failed queue jobs

database table queue:flush Flush all of the failed queue jobs
queue:forget Delete a failed queue job
queue:listen Listen to a given queue
queue:restart Restart queue worker daemons after their current job
queue:retry Retry a failed queue job
queue:table Create a migration for the queue jobs database table
queue:work Start processing jobs on the queue as a daemon

route route:cache Create a route cache file for faster route registration
route:clear Remove the route cache file
route:list List all registered routes

schedule schedule:finish Handle the completion of a scheduled command
schedule:run Run the scheduled commands

session session:table Create a migration for the session database table
storage
storage:link Create a symbolic link from “public/storage” to “storage/app/public”

vendor vendor:publish Publish any publishable assets from vendor packages

view view:cache Compile all of the application’s Blade templates
view:clear Clear all compiled view files

There are quite a few commands but don’t worry at all, you may not end up using all of them.

In the early steps of using Laravel for the first time, you will end up spending most of your time in routes/web.php

Let’s take a look at the web.php file in your code editor. With some basic understanding of programming, you should be able to tell quite quickly what the route is doing.

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

So Laravel is telling the browser to make a GET request, the ‘/’ is the homepage URL and we then tell the function to return the view ‘welcome’. Sounds very simple, doesn't it?

Here is some basic information on routing from the official Laravel website;

All Laravel routes are defined in your route files, which are located in the routes directory. These files are automatically loaded by the framework. The routes/web.php file defines routes that are for your web interface. These routes are assigned the web middleware group, which provides features like session state and CSRF protection. The routes in routes/api.php are stateless and are assigned the api middleware group.

For most applications, you will begin by defining routes in your routes/web.php file. The routes defined in routes/web.php may be accessed by entering the defined route's URL in your browser. For example, you may access the following route by navigating to http://your-app.test/user in your browser

EDITING THE WELCOME PAGE

To get to the welcome page, you will need to go to /resources/views/welcome.blade.php

This is where you will find the HTML and styling for the page. Let’s update the heading “Laravel” to “Learning Laravel”.

<div class=”title m-b-md”>Learning Laravel</div>

Now refresh the page in the browser to see if that change has been reflected.

The title has now been updated after making the change in the source code

Voila — you have now mastered the first step in locating a view and making a change to it that is reflected in the browser. Give yourself a pat on the back!

CREATING YOUR OWN ROUTE

Let’s finish off by creating a route of our own, head over back to /routes/web.php copy the current route and set a URL and a view for it to return. Let me show you how to create an about route inside the file.

Route::get(‘/about’, function () {  
    return view(‘about’);  
});

We are telling the route to get the following URL which is /about and then to return a view called ‘about’. It’s good practice to keep the name of the URL and View the same to avoid any confusion. It wouldn't make sense if you had a URL ‘about’ and the view was called ‘random’.

Try navigating to /about in the browser? Oops! What’s gone on here?

View not found error in Laravel

Laravel is telling us that there is no view about created so it cannot, therefore, load it. Go back to your project folder, head over into /resources/views/ and create a file called about.blade.php. You have to include the word blade when creating a view as it’s Laravel templating engine that is being used to render the file.

Once that has been created, add some HTML to the page and then reload the page in the browser, this will get rid of the error message and return the HTML for the about page.

There you go — the about page is now accessible and working!

We now need to set up a navigation of links so we can access the homepage and the about page. Go to the welcome.blade.php and insert a hyperlink to the about page.

<a href=”/about” title=”About”>About</a>

Reload the homepage and you should now see a link that goes to the About page. We have a problem though, we need to access the homepage in order to get to the new page we’ve created. This is not how navigations are meant to work! We could copy the link and insert it into the about.blade.php file, this isn't the way of doing it, but for now, you can add the hyperlink there to see how linking to each view works.

In the next article, I will show you the correct way of building up a navigation instead of repeating the HTML on every view we create. We will be using layouts.

If you’ve enjoyed this article, give it a clap and share it amongst family & friends. You never know, it may help them in their journey in learning laravel. If you have any comments, feel free to use the comments box or tweet me at @mjcoder on twitter.

Thanks for reading.

So you may have been wondering where on earth have I gone and why there haven't been any updates of my Laravel journey, well I’ll keep this short and sweet, I broke my little finger & torn the ligament in it, so you can imagine I had one floppy finger. I also became a proud father just over 3 months ago and life has just been a rollercoaster — now I have some time off work so I thought I’d best get back to this journey.

Image created on Canva

To begin installing Laravel on Windows you need to decide which of these tools you will be using on Windows OS to spin up a development environment. You have the choice of using the following but not restricted to;

• XAAMP
• MAMP
• AMPPS

I’ll be using XAAMP as I have this already installed on my computer. I won’t guide you on how to install XAAMP as there are loads of tutorials out there that will show you how to get that done.

Before installing Laravel, you need to install Composer. You can either install it locally or globally. Locally means inside the project folder and globally means system-wide — so it’s accessible outside of the project folder.

Composer is a tool for dependency management in PHP. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you.

As we are using a Windows OS we need to download composer using this link. This will ensure that Composer will install the latest version. We always want the most up to date version of Composer.

To quickly install Composer in the projects directory you need to run the following command in your terminal. You can use GitBash or the built-in terminal in Visual Code.

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"  
php -r "if (hash\_file('sha384', 'composer-setup.php') === '93b54496392c062774670ac18b134c3b3a95e5a5e5c8f1a9f115f203b75bf9a129d5daa8ba6a13e2cc8a1da0806388a8') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP\_EOL;"  
php composer-setup.php  
php -r "unlink('composer-setup.php');"

It’s really important that we install Composer globally, you only have to do this once, after all, we don’t want to be repeating ourselves for every new project we spin up. DRY!

You can find out how to do this by checking the official documentation on the Composer website here.

Installing Laravel via Composer

Fingers crossed that installing Composer has gone to plan if you’ve struggled, I’d recommend watching a few videos on YouTube on getting started with Composer.

Run this command in your terminal;

composer global require laravel/installer

Make sure to place composer’s system-wide vendor bin directory in your $PATH so the laravel executable can be located by your system. This directory exists in different locations based on your operating system; however, some common locations include:

macOS: $HOME/.composer/vendor/bin

GNU / Linux Distributions: $HOME/.config/composer/vendor/bin

Once that has finished installing, the laravel new command will be available to use. The next command you need to run is;

laravel new <this can be named anything>

After the keyword, “new” give the laravel installation a suitable name. For example, if you are going to create a blog, then I’d call it a blog.

Here is a short video on how to install Laravel;

Local Development Server

If you have PHP installed locally and you would like to use PHP’s built-in development server to serve your application, you may use the serve Artisan command. This command will start a development server at [http://localhost:8000](http://localhost:8000:):

You should now be fully set up and be able to access the laravel installing on the localhost URL. I’ve kept this quite brief and not gone into greater detail on how to install Laravel & Composer as there are loads of video guides out there available to you.

I hope you’ve enjoyed this post if you have, give it a clap and share. It’ll be highly appreciated. And if you want to join me on the Laravel journey, drop me a comment in the comments section & I’ll get back to you. Thanks.

Laravel Logo

So yeah, I’m starting to learn Laravel. If you Google Laravel, your almost certain to come across Laravel PHP Framework on the first page. It’s widely used amongst PHP developers. There are quite a few frameworks out there such as;

• CakePHP
• CodeIgniter
• Symfony
• Zend

Why should you use a PHP Framework?

I’ll list a few good reasons why every developer should use a framework;

• Less Code — We don’t want to lots of DRY code.
• Faster development — we all want to develop something quick & not spend an eternity on doing the basics.
• Community Support — you’ll be able to collaborate with other developers, or if you have a problem, you’ll be able to post the problem on the support forum(s) and get help.
• Packages and Utilities — you’ll be able to integrate packages/utilities from fellow developers into the framework.
• Database Utilities/Migrations — migrate data from your code straight into the database.
• Authentication — save time writing your own code to process/validate authentications, most if not all frameworks should have this built in for you.

Why do you want to learn Laravel?

The main reason why I want to learn Laravel is because it’s amazing framework packed with so many features that it makes life easier for the developer. I’ve seen first hand at what the developer can do with it and how quickly you can start putting stuff together from logins to dashboards.

A fellow Artisan developer, Ivo Nunes uses Laravel quite heavily and has built some amazing websites with the framework. i was intrigued at how quickly he would go from setting up the database, to the backend of Laravel and then build a front-end on top of the framework at such a ridiculous rate.

I wanted some of that quickness too! So here I am starting this exciting journey, the goal is more than just learning the framework, it’s to build something amazing with it. The possibilities with Laravel is endless. That is the greatest thing about it.

Photo by sydney Rae on Unsplash

How do you think you’ll get on?

I feel confident, there are no nerves just pure excitement. I’ve already watched a few tutorial videos on YouTube by Traversy Media so it’s already given me a head start. Brad explains things quite clearly & has loads of web development related videos that you can watch. i definitely will be diving in to those videos once I get to grips with Laravel.

There’s always support and very well written documentation at Laravel so I won’t be lost, there’s always going to be support, whether that’s through forums, social media, in-person, there’s always an Artisan on hand happy to help.

What do you want to take away from this journey?

Firstly, I don’t think this journey will end, it’s going continue regardless, this journey will just continue to grow and the learning growth will just be rising. What I’d like to take away from this journey is to have a PHP framework under my belt/skill set. It can do no harm.

With starting this journey it’ll grow me as a web developer which will ultimately end in me building more than just websites. As a developer you can’t stick to what you already know, you should always be challenging yourself to become a better web developer. My aim is to become a full-stack developer. It won’t be easy but let’s get the journey started.