Forem: Junaid Javed

Using the booted Method in Laravel Eloquent Models for CRUD Event Listening and Cache Resetting

Junaid Javed — Tue, 14 Mar 2023 05:36:19 +0000

Introduction to the booted method in Eloquent

In Laravel's Eloquent ORM, the booted method is called when an Eloquent model is instantiated. This method provides a convenient place to register event listeners or perform other setup tasks.

By using the booted method, you can keep your model logic organized and easy to maintain. In this post, we'll explore how to use the booted method to listen for CRUD events and reset cache when creating or updating a model.

Lets understand it using example:

Suppose you have a Laravel application with a Usermodel that is frequently accessed and updated. To speed up queries and reduce database load, you decide to cache user data using Laravel's Cache façade.

To cache user data, you'll need to store it using a unique cache key. You could use the user's ID as the cache key, but what happens when the user's data changes? You'll need to update the cache key every time the user is updated to ensure that the cache is not stale.

To automate this process, you can use the booted method to listen for the creatingand updatingevents on the Usermodel, and reset the cachefor the user being created or updated.

Registering event listeners

To listen for CRUD events, you can register event listeners using the creating, created, updating, updated, saving, saved, deleting, and deleted methods on the model's static boot method.

In this example, we'll use the creatingand updating events to reset cache for the user being created or updated.

Here's how you can define event listeners in the boot method of the User model:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Cache;

class User extends Model
{
    protected static function booted()
    {

        static::creating(function ($user) {
            Cache::forget('user_' . $user->id);
        });

        static::updating(function ($user) {
            Cache::forget('user_' . $user->id);
        });
    }
}

Resetting cache

To reset cache for a model, you can use Laravel's Cache facade. The Cache facade provides a simple API for storing and retrieving data from a variety of cache backends.

For example, to cache a user model by their ID, you can use the remember method of the Cache façade:

$userId = 1;

$user = Cache::remember('user_' . $userId, $minutes, function () use ($userId) {
    return User::find($userId);
});

In the above code, the remember method caches the user model with ID 1 for the specified number of minutes. If the cache is not already set, the closure passed to remember is called to retrieve the data and cache it.

To reset cache for a user when they are created or updated, we use the forget method

Conclusion

In this post, we've explored how to use the booted method in Eloquent models to listen for CRUD events and reset cache when creating or updating a model. By using event listeners and the Cache façade, you can keep your model logic organized and easy to maintain.

orderByRaw Method In Laravel

Junaid Javed — Mon, 27 Feb 2023 04:59:10 +0000

The orderByRaw method allows you to specify a raw SQL expression to use for sorting the results of a query. This can be useful when you need to sort by a calculated value, a complex expression, or a column that is not directly available in the database.

Here's an example that demonstrates how to use orderByRaw in Laravel.

Example # 1

$users = DB::table('users')
    ->orderByRaw('LENGTH(name) DESC')
    ->get();

In this example, we first select all columns from the users table using the table method of the DB facade.

We then use the orderByRaw method to specify a raw SQL expression to use for sorting the results. The expression LENGTH(name) calculates the length of the name column for each user, and the DESC keyword sorts the results in descending order based on this calculated value.

Finally, we use the get method to retrieve the sorted results from the database.

This will generate a SQL query that looks something like this:

SELECT * FROM users ORDER BY LENGTH(name) DESC

This query returns a list of all users, sorted in descending order based on the length of their names.

Example # 2

Let's assume we have a roles table with the following columns:

id | name        | level
---|-------------|------
1  | Admin       | 3
2  | Moderator   | 2
3  | Contributor | 1

You want to sort the roles based on their level of importance, rather than their alphabetical order. Here's how we can do that using orderByRaw:

$roles = DB::table('roles')
    ->orderByRaw('CASE WHEN level = 3 THEN 1 WHEN level = 2 THEN 2 ELSE 3 END')
    ->get();

In this example, you can use the orderByRaw method to specify a raw SQL expression to use for sorting the roles. The expression uses a CASE statement to assign a numerical value to each role based on its level of importance. We assign the value 1 to roles with level 3, 2 to roles with level 2, and 3 to all other roles.

The ORDER BY clause then sorts the roles based on these assigned values, with the roles with the lowest assigned value (i.e., the most important roles) appearing first in the result set.

This will generate a SQL query that looks something like this:

SELECT * FROM roles ORDER BY CASE WHEN level = 3 THEN 1 WHEN level = 2 THEN 2 ELSE 3 END

This query returns a list of all roles, sorted based on their level of importance.

Example # 3:
Here's an example of a more complex orderByRaw expression in Laravel:

Assume we have a sales table with columns id, product_id, quantity, price, and created_at. We want to retrieve a list of the top 10 products by revenue for the current month, and include the total revenue and quantity sold for each product. We can do this using the following query:

$topProducts = DB::table('sales')
    ->select('product_id', DB::raw('SUM(quantity) as total_quantity'), DB::raw('SUM(price * quantity) as total_revenue'))
    ->whereBetween('created_at', [Carbon::now()->startOfMonth(), Carbon::now()->endOfMonth()])
    ->groupBy('product_id')
    ->orderByRaw('total_revenue DESC')
    ->take(10)
    ->get();

In this example, the select method to select the product_id, and calculate the total_quantity and total_revenuecolumns using the SUM and DB::raw methods.

We then use the whereBetween method to filter the results to only include sales made during the current month.

Next, we use the groupBymethod to group the results by product_id.

We then use the orderByRawmethod to specify a raw SQL expression to use for sorting the results. The expression total_revenueDESC sorts the results in descending order based on the total_revenue column that we calculated in the select method.

Finally, we use the take method to limit the results to the top 10 products by revenue, and use the get method to retrieve the results from the database.

This will generate a SQL query that looks something like this:

SELECT product_id, SUM(quantity) as total_quantity, SUM(price * quantity) as total_revenue  FROM sales 
WHERE created_at BETWEEN '2023-02-01 00:00:00' AND '2023-02-28 23:59:59' 
GROUP BY product_id 
ORDER BY total_revenue DESC 
LIMIT 10

This query returns a list of the top 10 products by revenue for the current month, sorted based on the total revenue generated by each product. Each row in the result set includes the product_id, total_quantity, and total_revenuefor the corresponding product.

Note that the expression passed to orderByRaw should be a valid SQL expression and properly escaped to avoid SQL injection vulnerabilities. Also, if you need to sort by multiple columns or expressions, you can chain multiple orderByRaw calls or use the orderBymethod instead.

Laravel Request Lifecycle Overview

Junaid Javed — Tue, 21 Feb 2023 16:51:43 +0000

Would you like to learn about the Request Life Cycle in Laravel? This Article refers to the series of stages through which the framework processes a given request, ultimately providing a response to the user. Let’s examine this process step-by-step to better understand it.

Entry Point (Auto Loader)

The starting point for all requests in a Laravel application is the public/index.php file. This file is responsible for directing all incoming requests to the correct location within the application.
When a request is made, the index.php file first loads the auto-loader files created by Composer. This allows for the dynamic loading of classes and dependencies as needed.

After the auto-loader files have been loaded, the index.php file retrieves an instance of the Laravel application from the bootstrap/app.php script.

Kernel

Once the application instance generated ✅
The Incoming request will be handled by the kernel. There are two types of kernel in Laravel
1) HTTP kernel
2) Console kernel.
Incoming Request can be handled by either HTTP kernel or Console kernel depending on the request type.
HTTP kernel, which is placed in app/Http/Kernel.php
It just receive a Request and return a Response.

Bootstrappers that are defined by the Kernel class, which configures error handling, configure logging, detect environments and other tasks to be done before the request handled.
HTTP kernel also Register & Execute Middleware’s (Manage HTTP session, Detect maintenance mode, verify CSRF token, etc.)

Service Providers

Next step of the kernel is to load service providers as part of the bootstrapping action. Providers that are needed for the application are placed in config/app.php configuration file.

All of the service providers for the application are configured in the config/app.php configuration file’s providers array.

First, the register method will be called on all providers, then, once all providers have been registered, the boot method will be called.

Service providers are responsible for bootstrapping all of the framework’s various components, such as the database, queue, validation, and routing components.

Bootstraping involves, Initializing configurations, detecting application environment, configure error handling, configure logging and other task needs to execute before request being handled

Dispatch Request

Once the application have been bootstrapped and all service providers are registered and booted, the Request will be handed over to the router for dispatching.

The router will dispatch the request to a route or controller, as well as run any route specific middleware.

The Router will handle the HTTP Request and either direct it to a Controller or return a view or response directly without a controller. These routes are defined in the app/routes.php file.

The Controller, located at app/controllers/, performs specific actions and sends the data to a View.

The View, located at app/views/, formats the data and sends it back as an HTTP Response.

That’s All

Laravel Tip (Select Columns using eloquent all method)

Junaid Javed — Sun, 23 Jan 2022 16:39:13 +0000

Select Columns through Laravel Eloquent

Now we can select the columns to run the when using the Model::all() method. No Need to use additional select() method

//Instead of this
$users = User::select(['id','name','email'])->get();
//Use this one
$users = User::all(['id','name','email']);

Deploy Laravel on AWS Elastic beanstalk

Junaid Javed — Sat, 22 Jan 2022 18:23:20 +0000

Introduction

In this quick tutorial, you will learn how to deploy a Laravel application on AWS elasticbeanstalk. By the end of the tutorial, you will be able to deploy a Laravel application on Elasticbeanstalk, update the application and also connect it to a database.

AWS Elastic Beanstalk is an orchestration service offered from Amazon Web Services for deploying infrastructure which orchestrates various AWS services, including EC2, S3, Simple Notification Service, CloudWatch, auto scaling, and Elastic Load Balancers.

Install Laravel

We create a fresh Laravel application using composer

composer create-project --prefer-dist laravel/laravel JJLaravelApp

Start Laravel

We will start Laravel on the local server

cd `JJLaravelApp` && php artisan serve

The Laravel Application should now be running on http://localhost:8000

Setup AWS Elasticbeanstalk Environment

If you do not already have an AWS account, you need to sign up here. This will give you access to Elasticbeanstalk and other AWS Services.

Create an Elasticbeanstalk Application

Click the Get Started button. You will be taken to an application creation page

Give a name to your application. In this case, I have named mine jj-laravel-app. Also, select PHP as the platform. Then select “Upload your code” in the application code section.

Prepare Laravel Application for Deployment

Zip Laravel Application

We have to create a zip file of our entire Laravel application files, excluding the vendor folder. Note that you should not zip the parent JJLaravelApp folder, instead create a zip of the application files themselves.

Once the zip file is ready, click on the “Upload” button to upload a zip file containing your Laravel application code.

You will be prompted to either upload a local file or a public S3 URL. Choose “Local file” and click the “Upload” button to upload the zip file.

Deploy Laravel to Elasticbeanstalk Environment

Now that the Zip file is successfully uploaded, click the “Create Application” button. Elasticbeanstalk will start provisioning the Laravel application.

After a few minutes, the Laravel application should be successfully deployed.

The top right corner of the dashboard shows a URL link to the deployed Laravel application. Click on it to navigate to the page.

You should see a “403 Forbidden” error on the provided link, saying “permission to access / on the server isn’t granted”.

Update Application Root Folder

We need to set the public folder as the root folder. Go back to the Application dashboard and click on “Configurations”, then modify Software.

Update the “Document root” to /public, then click “Apply”. ElasticBeanstalk will then update the environment with the new configuration. That should take a few seconds.

Now go back to the browser tab and refresh it.

Our Laravel app is now Live!

Update Laravel Application on ElasticBeanstalk
o you may be wondering, how do you update the deployed Laravel application.

Lets make a quick update to the app.

Go to your favorite IDE and edit the welcome screen (welcome.blade.php). Change “Laravel” word to “JJ Laravel ”, save it, then zip the files again.

Now that we have zipped the updated Laravel app, Navigate to Elasticbeanstalk dashboard and click on the jj-laravel-app application. Select “Application Versions”. You will see the initially uploaded zip file.

Click the “Upload” button to upload a newer version of the application.

Add a Version label, a description, then choose the newly updated zip file for the app, then click “Upload”

A new version of the Laravel app will now be added to the list of app versions. Elasticbeanstalk lets you choose which version of your application you may want to deploy at anytime. You can also choose to rollback to an earlier version of the app by simply redeploying the source.

Select the new version and click “Deploy”. Elasticbeanstalk will now begin the process of updating the Laravel application. Wait a few seconds and everything should be ready.

Go back to the browser tab and refresh the page:

We have successfully deployed a new version of the Laravel Application.

Connecting to a Database

There are two ways to connect your application on Elasticbeanstalk to a database:

Using an internal RDS database: AWS Elasticbeanstalk provides an internal database for your application, but with a caveat — the database gets deleted too if you delete your Elasticbeanstalk app environment. It is therefore more suitable for development and testing purposes, while its discouraged for production usage.
Using an external database: Connect to an external database, be it a standalone RDS or a remote database, with required endpoints and credentials, through the environmental variables Elasticbeanstalk provides or through the .env file in the Laravel application.

Provision an Internal Elasticbeanstalk RDS Database

Go to the Application dashboard and click on “Configurations”, then modify Database.

You are prompted to choose the type of database you will like provisioned. Select the Mysql engine with a t2.micro database instance class. Choose a username and a password with which you will access the database. Select delete for retention and set Availability to Low. Now click “Apply”. Elasticbeanstalk will begin to provision the database. This may take a few minutes.

Once the database is provisioned, you will see a link to the database endpoint. You can now use this endpoint, together with the other credentials(username, password e.t.c) to connect to the database.

The procedure to connect to the internal database is the same for connecting to the external database — pass the credentials to the environmental properties of the Application.

Connect Elasticbeanstalk Application to External/Internal Database

The properties specified in the Elasticbeanstalk environmental properties usually overrides the value for the same property specified in the Laravel .env environment file.

Go to the Application dashboard and click on “Configurations”, then modify Software. Scroll to the bottom:

Specify the name-value pairs for the environment variables. This is where you provide the endpoint for the internal or external database and all other database credentials. Once that’s done, click “Apply”.

You have now successfully connected the Laravel Application on Elasticbeanstalk to a database.

Conclusion

In this tutorial, we created a fresh Laravel application and deployed it to AWS Elasticbeanstalk. We also created and deployed different versions of this application. Lastly, we connected it to an internal and external database, through the software environment properties.

How To Deploy Laravel Project on EC2 AWS .

Junaid Javed — Sat, 22 Jan 2022 16:32:59 +0000

Connect to EC2 instance using your private key ( Key Pair ).

Update your Libraries

$ sudo apt-get update

Install Apache2

$ sudo apt-get install apache2

Now copy the IPv4 Public IP Address of your EC2 instance and hit on the browser. If you see a screen something like below , you are good to go. Apache server is working!

Install PHP and useful packages

$ sudo apt-get install php
$ php --version
$ sudo apt-get install php7.4-cli php7.4-common php7.4-curl php7.4-gd php7.4-json php7.4-mbstring php7.4-intl php7.4-mysql php7.4-xml php7.4-zip

Usually, when a user requests a directory from the web server, Apache will first look for a file named index.html. If you want to change Apache to serve php files rather than others, move index.php to first position in the dir.conf file as shown below.

$ sudo vi /etc/apache2/mods-enabled/dir.conf

This will install mysql server but this will not prompt anything to configure mysql.

Configuring MySQL

$ sudo mysql_secure_installation

This way you can make some changes to your MySQL installation’s security options.

Note that even though you’ve set a password for the root MySQL user, this user is not configured to authenticate with a password when connecting to the MySQL shell because it uses auth_socket by default.

In order to use a password to connect to MySQL as root, you will need to switch its authentication method from auth_socket to mysql_native_password by using following commands.

$ sudo mysql

To configure the root account to authenticate with a password, run the following ALTER USER command. Note that this command will change the root password you set in mysql_secure_installation

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'yourpassword';

Then, run FLUSH PRIVILEGES which tells the server to reload the grant tables and put your new changes into effect:

FLUSH PRIVILEGES;

Now You are done with setting up your mysql server on your EC2. you can use your credentials in your laravel project.

Install Composer

$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
$ php -r "if (hash_file('sha384', 'composer-setup.php') === 'e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
$ php composer-setup.php
$ php composer-setup.php --install-dir=bin --filename=composer
$ php -r "unlink('composer-setup.php');"
$ composer --version

Install Git

$ sudo apt-get install git-core

Clone Your Repository

Change to /var/www/html directory and clone your Laravel Project there using following commands:

$ cd /var/www/html
$ sudo git clone https://github.com/username/reponame.git
$ cd reponame

Adding .env File to your Laravel project

$ sudo vi .env

Installing Libraries In Project

$ sudo composer install

Read Write Permissions for your Project

sudo chmod 777 -R storage/
sudo chmod 777 -R bootstrap/

Apache Configuration

By Default Apache open /var/www/html/index.html Now we have to open our Laravel project when we go to the public IP of the EC2.
Go to /etc/apache2/sites-available/000-default.conf and change the DocumentRoot as shown below:

$ sudo vi /etc/apache2/sites-available/000-default.conf

Restart your Apache

$ sudo systemctl restart apache2

Now you have successfully deployed your laravel Project on AWS ,
Which you can easily access through your public IPV4 IP Address.