DEV Community: Dharmik Bhadkoliya

The State Pattern in Laravel: Like a Magician for Your App’s Logic

Dharmik Bhadkoliya — Tue, 04 Feb 2025 04:19:59 +0000

Hey there!
Let’s talk about something magical that can make your Laravel projects cleaner, easier to understand, and a lot more fun to work with the state pattern. Don’t worry if you’re not familiar with it yet, I will explain everything using a simple and relatable example.

Why the State Pattern is Awesome

Clean Code: No more messy if-else blocks. Each state has its own class and handles its own logic.

Easy to Add States: Need a new state? Just create a new class. No need to touch existing code.

Safe Transitions: You can’t accidentally do something invalid, like shipping a pending order.

Readable and Fun: The code is easier to read, understand, and maintain.

Why Use the State Pattern?

Imagine you’re building a shopping app. Orders can go through several stages:

Pending : The order is created but not confirmed yet.
Confirmed : The order is confirmed and ready to be packed.
Shipped : The order is on its way to the customer.
Delivered : The order has been delivered.

Each of these states has its own rules. For example, you can’t ship an order that’s still pending, and you can’t deliver an order that hasn’t been shipped. Writing this logic with a bunch of if-else or switch statements can get really messy, really fast. That’s where the state pattern comes in to save the day!
The state pattern helps us organize this logic by creating separate classes for each state. It’s like giving each state its own little brain to handle what it can and cannot do. Cool, right?

The Order States: Breaking It Down

Let’s say our order can do three things:

Confirm : Move the order to the "Confirmed" state.
Ship : Move the order to the "Shipped" state.
Deliver : Move the order to the "Delivered" state.

We’ll create a system where each state knows what actions it can perform. Ready? Let’s build it!

Step 1: Create the State Interface

The OrderStateInterface is like a rulebook for all order states. It makes sure every state knows what to do when you confirm, ship, or deliver an order. You'll find this interface in App/States/Order/OrderStateInterface.php, and it keeps things organized by requiring each state to follow the same set of rules.

namespace App\States\Order;
interface OrderStateInterface
{
    public function confirm(): void;
    public function ship(): void;
    public function deliver(): void;
}

Step 2: The Base State Class

We’ll make a base class for all states. If a state doesn’t support an action, it will throw an error.

namespace App\States\Order;
use App\Models\Order;
use Exception;

abstract class OrderState implements OrderStateInterface
{
    public function __construct(protected Order $order)
    {
    }

    public function confirm(): void
    {
        throw new Exception("You can’t confirm this order right now!");
    }

    public function ship(): void
    {
        throw new Exception("You can’t ship this order right now!");
    }

    public function deliver(): void
    {
        throw new Exception("You can’t deliver this order right now!");
    }
}

Step 3: Create the Concrete States

Pending State

The order is still pending and can only be confirmed.

namespace App\States\Order;
class PendingState extends OrderState
{
    public function confirm(): void
    {
        $this->order->update(['status' => 'confirmed']);
        $this->order->state = new ConfirmedState($this->order);
        // Handle notifications, emails, etc.
    }
}

Confirmed State

The order has been confirmed and can now be shipped.

namespace App\States\Order;
class ConfirmedState extends OrderState
{
    public function ship(): void
    {
        $this->order->update(['status' => 'shipped']);
        $this->order->state = new ShippedState($this->order);
        // Handle notifications, emails, etc.
    }
}

Shipped State

The order is on its way and can now be delivered.

namespace App\States\Order;
class ShippedState extends OrderState
{
    public function deliver(): void
    {
        $this->order->update(['status' => 'delivered']);
        $this->order->state = new DeliveredState($this->order);
        // Handle notifications, emails, etc.
    }
}

Delivered State

The order has been delivered. Nothing more can be done.

namespace App\States\Order;

class DeliveredState extends OrderState
{
    // No actions allowed here.
    // Handle notifications, emails, etc.
}

Step 4: Update the Order Model

The order model will figure out what state it’s in and behave accordingly.

namespace App\Models;

use App\States\Order\{OrderStateInterface, PendingState, ConfirmedState, ShippedState, DeliveredState};

class Order extends Model
{
    protected $fillable = ['status'];

    public function orderState(): OrderStateInterface
    {
        return match ($this->status) {
            'pending' => new PendingState($this),
            'confirmed' => new ConfirmedState($this),
            'shipped' => new ShippedState($this),
            'delivered' => new DeliveredState($this),
            default => throw new \Exception("Unknown state"),
        };
    }
}

Step 5: Using It in a Controller

Here I am taking different methods to use states for examples:

<?php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Order;
use App\States\Order\PendingState;
use Exception;

class OrderController extends Controller
{
    public function confirm(Order $order)
    {
        try {
            if ($order->orderState() instanceof PendingState) {
                $order->orderState()->confirm();
                return redirect()->route('orders.index')->with('success', "Order #{$order->id} has been confirmed.");
            }

            return redirect()->route('orders.index')->with('error', "Order #{$order->id} cannot be confirmed in its current state.");
        } catch (Exception $e) {
            return redirect()->route('orders.index')->with('error', $e->getMessage());
        }
    }

    public function updateState(Order $order, string $action)
    {
        try {
            if (!method_exists($order->orderState(), $action)) {
                return redirect()->route('orders.index')->with('error', "Invalid action: {$action} for Order #{$order->id}.");
            }

            $order->orderState()->$action();
            return redirect()->route('orders.index')->with('success', "Order #{$order->id} has been updated successfully.");
        } catch (Exception $e) {
            return redirect()->route('orders.index')->with('error', $e->getMessage());
        }
    }

    public function ship(Order $order)
    {
        return $this->updateState($order, 'ship');
    }

    public function deliver(Order $order)
    {
        return $this->updateState($order, 'deliver');
    }

    public function index()
    {
        return view('welcome');
    }
}

Conclusion

The state pattern is a powerful way to manage application logic, making your Laravel app cleaner, more maintainable, and scalable. By organizing state-dependent behaviors into separate classes, you eliminate messy conditionals and improve readability. Implementing this approach in your projects will ensure a better development experience and fewer bugs. Try it out in your next Laravel project and see the magic happen!

Laravel Observers: The Silent Ninjas of Your Application Lifecycle

Dharmik Bhadkoliya — Wed, 06 Nov 2024 12:46:06 +0000

Introduction

Imagine that whenever you submit a form on a website, An invisible assistant comes in and checks everything again. Add additional details Or even send a welcome letter without you having to lift a finger. Laravel observers are like behind-the-scenes assistants who work quietly. And it's powerful to handle all the tasks when you need them. In this post, we'll dive into how observers work in Laravel, why they're your app's silent ninjas in model event handling. and how to get the most out of those events in real-world examples.

What are Laravel Observers?

Laravel Observers are listener classes that help manage the lifecycle of your model by observing specific events, such as creating, updating, or deleting. Observers can define actions for each of these events. Keep your controllers and models clean and focused. The Observers act as "event experts" within your application Observers will handle the backend work required to improve your codebase. and improve organization and efficiency With event-driven work separation. Observers contribute to a more modular and maintainable application structure.

Why Use Observers?

1. Cleaner Controllers and Models: Observers handle repeated actions, letting your controllers and models focus on their main jobs without distraction.

2. Code Reusability: You can consolidate related actions in one place, making your code more readable and maintainable.

3. Error Handling: Observers help you avoid errors by automating tasks like data validation or background updates whenever a model changes.

4. Automatic Event Handling: Want to trigger an action every time a record is created or updated? Observers have your back.

In short, Observers are fantastic for organizing logic that you want to execute during the various stages of your app’s lifecycle.

Eloquent Hooks Overview:

- Retrieved: Triggered after a record is retrieved from the database.
- Creating: Fires just before a new record is created.
- Created: Executes after a new record is created successfully.
- Updating: Activates before an existing record is updated.
- Updated: Fires after a record has been updated.
- Saving: Runs before a record is saved, whether it's a new creation or an update.
- Saved: Occurs after a record has been saved, whether newly created or updated.
- Deleting: Initiates before a record is deleted or soft-deleted.
- Deleted: Activates after a record is deleted or soft-deleted.
- Restoring: Fires before a soft-deleted record is restored.
- Restored: Runs after a soft-deleted record has been successfully restored.

Step-by-Step Guide: How to Create and Use Observers

Let's discuss Observers with a real-world example. Imagine we’re building a blogging app, and every time a user publishes a post, we want to:

Automatically generate a slug from the title.
Notify an admin.
Record the publish date.

Here’s how we can make this happen with Laravel Observers!

Step 1: Create the Observer Class
Laravel makes it easy to generate an observer class. Run this command:

php artisan make:observer PostObserver --model=Post

This will generate a PostObserver class in the app/Observers directory and link it to our Post model.

Step 2: Define the Events in the Observer

Open up the PostObserver class, and you’ll see some handy methods already in place. Each method corresponds to a model event, like creating, updating, deleting, and more.

Let’s add our custom logic to the creating event so that it generates a slug and records the publish date:

use Illuminate\Support\Str;
class PostObserver
{
   public function creating(Post $post)
   {
       $post->slug = Str::slug($post->title);
       $post->published_at = now();
   }

   public function created(Post $post)
   {
      Notification::send(User::admin(), new PostPublishedNotification($post));
   }
}

Step 3: Register the Observer

Laravel offers two ways to do this: the ObservedBy attribute on the model or manually using the observe method

1.Using the ObservedBy Attribute

If you’re working with Laravel 10+, you can use the ObservedBy attribute directly on your model. This attribute simplifies Observer registration by automatically linking the Observer to the model:

use App\Observers\PostObserver;
use Illuminate\Database\Eloquent\Concerns\ObservedBy;

#[ObservedBy(PostObserver::class)]
class Post extends Model
{
   // Your Post model code
}

This approach is clean and keeps the Observer registration with the model itself, reducing setup steps and keeping your AppServiceProvider untouched.

2.Manually Registering the Observer
If you prefer (or are working in a Laravel version prior to 10), you can manually register the Observer in the AppServiceProvider’s boot method:

In your App\Providers\AppServiceProvider.php, add the observe method to link the Observer to the model:

use App\Models\Post;
use App\Observers\PostObserver;

public function boot()
{
   Post::observe(PostObserver::class);
}

Once registered, Laravel will trigger your Observer’s methods whenever the corresponding events occur on the Post model.

Step 4: Testing Your Observer

To see your observer in action, try creating or updating a post in your app. The slug will generate automatically, the publish date will set itself, and our hypothetical admin will receive a notification. Observers make all this happen quietly, just like a true ninja.

Thanks for reading! I hope this sparked some fresh ideas for your projects. If you're interested in bringing quality development to life, feel free to reach out—I’d love to connect and explore how we can make it happen.

Crafting a Laravel Search Macro: A Quick Guide

Dharmik Bhadkoliya — Fri, 08 Dec 2023 09:23:39 +0000

Macro is a powerful Laravel framework feature.You can apply Laravel Macros to expand on the functionality of Laravel components.The Macroable trait allows macros to be defined on any class.

Where can I apply a macro?
If you're doing the same thing over and over again with Laravel components in your system, think about using a macro. It makes your code clearer and easier to reuse.

For example, let's make a macro that adds a search feature to every model in our Laravel project.

Integration Steps:

Step 1: Install Laravel and Create a New Project
First, make sure you have Laravel installed on your computer. If not, you can install it by following the instructions in the official Laravel documentation. After installing Laravel, open your terminal or command prompt and type the following command to create a new Laravel project:

composer create-project laravel/laravel MacrosApp

If you already have an existing Laravel project, you can use it to build macros and enhance its functionality. Simply navigate to your project's root directory in the terminal and proceed with the following steps.

Step 2: Migrate & Seed the Database
Now that you've set up your Laravel project, the next step is to migrate and seed the database. This will create the necessary tables and populate them with sample data.

(a)Seed the Database:
Open the database/seeders/DatabaseSeeder.php file. You'll find code that seeds the database with sample data. Uncomment this code by removing the // at the beginning of the lines.

<?php
namespace Database\Seeders;
use Illuminate\Database\Seeder;


class DatabaseSeeder extends Seeder
{
    public function run(): void {
        \App\Models\User::factory(10)->create(); //Uncomment this line
    }
}

(b)Run Migrations & Seed:
Open your terminal or command prompt, navigate to your project's root directory, and execute the following command:

php artisan migrate --seed

Step 3: Create a Search Macro
To enhance search functionality in your Laravel project, we'll add a custom search macro. Open the App\Providers\AppServiceProvider file and define the macro within the boot method.

(a)Add a Simple Search Macro for a Single Attribute

use Illuminate\Database\Eloquent\Builder;

//...
public function boot(): void
    {
       Builder::macro('search', function(string $attribute, string $searchTerm) {
                    return $this->where($attribute, 'LIKE', "%{$searchTerm}%");
        });
    }

(b)Extend the Search Macro to Handle Multiple Attributes.
To accommodate searching across multiple attributes, we'll modify the search macro to accept an array of attributes.

use Illuminate\Support\Arr;
use Illuminate\Database\Eloquent\Builder;


public function boot(): void
    {
       Builder::macro('search', function($attributes, string $searchTerm) {
        foreach(Arr::wrap($attributes) as $attribute) {
            $this->orWhere($attribute, 'LIKE', "%{$searchTerm}%");
        }
        return $this;
        });
    }

This extended search macro allows you to specify an array of attributes, making it more versatile for searching across multiple fields. The orWhere method is used to build a query that matches any of the specified attributes with the given search term.

Step 4 : How to apply the macro for searching
Now, use the following macro to add a search to not just the User model but all models:
Open the routes/web.php file in your project. Add the following code to demonstrate using the search macro in routes.

<?php


use App\Models\User;
use Illuminate\Support\Facades\Route;

Route::get('/', function () {
    // searching a single column
    return User::search('email','example.com')->get();

   // searching on multiple columns
   return App\Models\User::search('name', 'mr')->search('email', 'example.org')->get();
});

In this example, we are using the search macro to find users by email and perform a combined search by name and email. Adjust the attribute names and search terms based on your actual model attributes.

Conclusion:
To sum it up, this guide shows how to use Laravel macros to make searching in your project easier. With a simple setup process and a search macro that works for one or multiple attributes, your code becomes cleaner and more adaptable. By following the steps and applying the search macro to your controllers & routes, you can quickly add search features to your models, improving your code's simplicity and efficiency.

Mastering Traits: The First Step to Clean & Efficient Laravel Code

Dharmik Bhadkoliya — Tue, 05 Dec 2023 04:35:26 +0000

Introduction

Laravel is a widely-used PHP framework for building web applications. It's known for its clean and powerful code. Within Laravel, there's a useful feature called 'traits' that helps you reuse and organize your code efficiently. In this guide, we'll take a closer look at Laravel traits. We'll explain what they are, why they matter, and show you how to use them effectively in your Laravel projects, step by step.

What Are Traits in Laravel?

In Laravel, traits are a way to reuse methods in multiple classes. They provide a mechanism for code reuse without the need for multiple inheritance, solving the problem of inheriting from multiple classes, which PHP can't handle. Traits are basically groups of methods that can be included within classes, giving you a flexible way to expand and share functionality.

Why Are Traits Useful in Laravel?

There are various benefits to using traits in Laravel:

Code Reusability: Traits enable you to specify and reuse common functionality across several classes, minimizing redundancy and making your code more maintainable.

Structure: Traits improve with code structure by grouping relevant methods together, hence improving code readability and reliability.

Flexibility: You can include multiple traits in a single class, which allows you the ability to mix and match functionality as needed.

Avoiding Multiple Inheritance Issues: Because PHP does not support multiple inheritance, traits allow you equal functionality without any issues.

Step 1: Install Laravel and Create a New Project

First, make sure you have Laravel installed on your computer. If not, you can install it by following the instructions in the official Laravel documentation. After installing Laravel, open your terminal or command prompt and type the following command to create a new Laravel project:

composer create-project laravel/laravel TraitApp

OR

laravel new TraitApp

Step 2: Create a Trait

Create a new trait in the Laravel project. In general, traits are placed in the app/Traits directory. Let's start with a basic LogTrait.php trait:

<?php
namespace App\Traits;

trait LogTrait {
    public function log($message) {
        \Log::info($message);
    }
}

Step 3: Apply the Trait in a Class

Let's put the LogTrait to use in a class. Create a new controller or any class where you would like to log messages:

<?php

namespace App\Http\Controllers;
use App\Traits\LogTrait;
use Illuminate\Http\Request;

class HomeController extends Controller
{
     use LogTrait;

     function index() : String {
        $this->log('LogTrait is Working !!');
        return 'Message logged!';
     }
}

Step 4 : Test the Trait

Create a route in your routes/web.php file to test the trait:

Route::get('/',[HomeController::class,'index']);

When you refresh your browser, the message "LogTrait is Working!!" will be logged, demonstrating the use of the LogTrait.

Conclusion:

In this guide, we explored the concept of Laravel traits and how they enhance code organization and reusability. By implementing these techniques, you can streamline your Laravel projects, leading to cleaner and more efficient code. Happy coding!