DEV Community: Asfia Aiman

Mastering Scoped Resource Routes in Laravel: A Practical Guide

Asfia Aiman — Thu, 17 Jul 2025 09:51:08 +0000

Laravel’s scoped implicit model binding is a game-changer for developers working with nested resources. It ensures that child models resolved through nested routes are automatically validated to belong to their parent models. In this blog, we’ll explore how to use the scoped method with a fresh example involving Blog and Post models, discuss when to use it, and explain why it’s a great choice for your Laravel applications. We’ll also include practical code examples to bring the concept to life.

Understanding Scoped Implicit Model Binding

Scoped implicit model binding simplifies handling nested resources by ensuring the child model (e.g., a post) belongs to the parent model (e.g., a blog). This feature eliminates the need for manual validation in your controllers, making your code cleaner and more secure. For example, when accessing a URL like /blogs/{blog}/posts/{post}, Laravel ensures the resolved Post belongs to the specified Blog.

When to Use Scoped Resource Routes

You should consider using scoped resource routes when:

Working with Nested Resources: Your application has parent-child relationships, such as blogs and posts, users and profiles, or categories and products.
Enforcing Data Integrity: You need to ensure that child resources are only accessible in the context of their parent to prevent unauthorized access.
Using Custom Keys: You want to bind child resources using fields other than the default id, such as a slug for SEO-friendly URLs.
Simplifying Controller Logic: You want to avoid writing repetitive relationship checks in your controllers.
Building RESTful APIs or Web Routes: Scoped routes work seamlessly for both web and API routes, ensuring consistent behavior.

Why Scoped Resource Routes Are a Good Idea

Using scoped resource routes offers several benefits:

Enhanced Security: Automatically validates that the child resource belongs to the parent, preventing users from accessing unrelated resources.
Cleaner Code: Eliminates boilerplate code for relationship checks, making controllers more concise and maintainable.
SEO-Friendly URLs: Supports custom keys like slug, enabling readable and search-engine-optimized URLs (e.g., /blogs/tech-blog/posts/laravel-tips).
Consistency: Leverages Laravel’s conventions to guess relationship names, reducing configuration overhead.
Error Handling: Automatically returns a 404 error if the child resource doesn’t belong to the parent, saving you from manual error handling.

Example: Scoped Routes with Blogs and Posts

Let’s walk through a complete example using Blog and Post models to demonstrate scoped resource routes.

1. Define the Models

Assume you have a Blog model with a one-to-many relationship to Post:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Blog extends Model
{
    protected $fillable = ['title', 'slug'];

    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

And a Post model:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = ['title', 'slug', 'content'];

    public function blog()
    {
        return $this->belongsTo(Blog::class);
    }
}

2. Create the Controller

Create a BlogPostController to handle post-related operations:

namespace App\Http\Controllers;

use App\Models\Blog;
use App\Models\Post;
use Illuminate\Http\Request;

class BlogPostController extends Controller
{
    public function show(Blog $blog, Post $post)
    {
        return view('posts.show', compact('blog', 'post'));
    }

    public function store(Request $request, Blog $blog)
    {
        $validated = $request->validate([
            'title' => 'required|string|max:255',
            'content' => 'required|string',
        ]);

        $post = $blog->posts()->create([
            'title' => $validated['title'],
            'slug' => \Str::slug($validated['title']),
            'content' => $validated['content'],
        ]);

        return redirect()->route('blogs.posts.show', [$blog, $post]);
    }
}

3. Define the Routes

In your routes/web.php file, define the scoped nested resource:

use App\Http\Controllers\BlogPostController;

Route::resource('blogs.posts', BlogPostController::class)->scoped([
    'post' => 'slug',
]);

This configuration registers routes like:

GET /blogs/{blog}/posts/{post:slug} for displaying a post.
POST /blogs/{blog}/posts for creating a new post.

4. Create a View

Create a Blade view (resources/views/posts/show.blade.php) to display the post:

<h1>Blog: {{ $blog->title }}</h1>
<h2>Post: {{ $post->title }}</h2>
<p>{{ $post->content }}</p>
<a href="{{ route('blogs.posts.index', $blog) }}">Back to Posts</a>

5. Testing the Route

With this setup, a URL like /blogs/tech-blog/posts/laravel-tips will:

Resolve the Blog with the slug tech-blog.
Resolve the Post with the slug laravel-tips, ensuring it belongs to the specified blog.
Display the post details in the view.

If the post doesn’t belong to the blog, Laravel throws a 404 error automatically.

Advanced Example: Custom Relationship Name

If your relationship name doesn’t match the plural of the route parameter (e.g., Blog has an articles relationship instead of posts), you can specify it explicitly:

Route::resource('blogs.articles', BlogPostController::class)->scoped([
    'article' => 'slug',
    'relationship' => 'articles',
]);

Here, Laravel uses the articles relationship on the Blog model to scope the query.

Practical Use Case: Why It Matters

Imagine you’re building a blogging platform where users can access posts only within the context of a specific blog. Without scoped binding, you’d need to manually verify the relationship in your controller:

public function show($blogId, $postSlug)
{
    $blog = Blog::findOrFail($blogId);
    $post = Post::where('slug', $postSlug)->where('blog_id', $blogId)->firstOrFail();
    return view('posts.show', compact('blog', 'post'));
}

With scoped implicit model binding, Laravel handles this for you, reducing the code to:

public function show(Blog $blog, Post $post)
{
    return view('posts.show', compact('blog', 'post'));
}

This not only saves time but also reduces the risk of errors and improves code readability.

Conclusion

Scoped resource routes in Laravel are a powerful tool for building robust, secure, and maintainable applications with nested resources. By using the scoped method, you can enforce parent-child relationships, support custom keys like slugs, and simplify your controller logic. Whether you’re building a blog, an e-commerce platform, or any application with hierarchical data, scoped routes help you write cleaner code and deliver a better user experience.

Start using scoped resource routes in your Laravel projects to take advantage of their security, simplicity, and flexibility!

Mastering Middleware Execution Order in Laravel 12

Asfia Aiman — Mon, 05 May 2025 05:00:14 +0000

Laravel’s middleware provides a convenient mechanism for filtering HTTP requests entering your application. From authentication to CSRF protection, middleware acts as the guardians of your app, ensuring requests meet specific criteria before reaching your business logic.

In Laravel 12, the order of middleware execution can make or break your application. This article dives deep into:

Middleware execution order
Middleware parameters
Terminable middleware
Managing the global middleware stack

Let’s master the art of middleware.

Understanding Middleware Execution Order

Middleware in Laravel executes in the order they’re registered.

Route::get('/profile', function () {
    // Your route logic
})->middleware(['auth', 'verified', 'log-activity']);

In this example:

auth middleware runs first.
Then verified.
And finally log-activity.

Sorting Middleware in Laravel 12

Sometimes, you need middleware to execute in a specific order — regardless of how they’re assigned to routes. Laravel 12 introduces the priority method in bootstrap/app.php:

->withMiddleware(function (Middleware $middleware) {
    $middleware->priority([
        \App\Http\Middleware\ImportantFirstMiddleware::class,
        \App\Http\Middleware\MustRunSecondMiddleware::class,
        \App\Http\Middleware\ThirdInLineMiddleware::class,
        // Add more in the order you need
    ]);
});

When to Use Middleware Priority

Use it when:

One middleware depends on another
You want a consistent global execution order
You have complex middleware chains with dependencies

Real-World Example: Multi-Tenant App

Suppose you're building a multi-tenant app with the following middleware:

IdentifyTenant: detects which tenant the request belongs to
SetupTenantDatabase: switches database
ApplyTenantTheme: customizes UI styles

Execution order is essential:

->withMiddleware(function (Middleware $middleware) {
    $middleware->priority([
        \App\Http\Middleware\IdentifyTenant::class,
        \App\Http\Middleware\SetupTenantDatabase::class,
        \App\Http\Middleware\ApplyTenantTheme::class,
    ]);
});

What Happens Without Proper Sorting?

Expect:

Broken features
Data inconsistencies
Security gaps
Performance degradation

Middleware Parameters

Laravel allows middleware to receive dynamic parameters.

Example: Subscription Check

class RequireSubscription
{
    public function handle(Request $request, Closure $next, string $level): Response
    {
        $user = $request->user();

        if (!$user || !$user->hasSubscription($level)) {
            return response()->json([
                'error' => 'This feature requires a ' . ucfirst($level) . ' subscription',
                'upgrade_url' => route('subscriptions.upgrade'),
            ], 403);
        }

        return $next($request);
    }
}

Usage

Route::get('/premium-content', fn () => 'Premium!')->middleware('subscription:premium');

Class-Based Syntax

Route::get('/analytics-dashboard', fn () => 'Analytics!')
    ->middleware(RequireSubscription::class.':business');

Multiple Parameters

Route::get('/developer-tools', fn () => 'Dev tools')
    ->middleware('subscription:premium,business');

Real-World Example: Age-Based Content Filtering

class ContentFilter
{
    public function handle(Request $request, Closure $next, int $minimumAge = 13, bool $skipWarning = false): Response
    {
        $user = $request->user();
        $userAge = $user?->age;

        if (!$userAge || $userAge < $minimumAge) {
            if ($skipWarning) {
                return redirect()->route('content.restricted');
            }
            session(['intended_url' => $request->fullUrl()]);
            return redirect()->route('content.warning', [
                'minimum_age' => $minimumAge,
            ]);
        }

        return $next($request);
    }
}

Usage

Route::get('/forums')->middleware('content.filter');
Route::get('/mature-content')->middleware('content.filter:18,true');
Route::get('/teen-content')->middleware('content.filter:16,false');

Terminable Middleware: After Response Hooks

Need to run logic after the response is sent? Use terminable middleware.

Example: Page View Logger

class TrackPageViews
{
    public function handle(Request $request, Closure $next): Response
    {
        return $next($request);
    }

    public function terminate(Request $request, Response $response): void
    {
        if ($request->ajax() || $response->getStatusCode() !== 200 || $request->method() !== 'GET') {
            return;
        }

        DB::table('page_views')->insert([
            'path' => $request->path(),
            'user_id' => $request->user()?->id,
            'user_agent' => $request->userAgent(),
            'ip_address' => $request->ip(),
            'viewed_at' => now(),
        ]);
    }
}

Register as Singleton

public function register(): void
{
    $this->app->singleton(\App\Http\Middleware\TrackPageViews::class);
}

Use Cases

Logging
Dispatching jobs
Cleanup tasks
Performance monitoring

Managing Laravel’s Global Middleware

Global middleware can be configured in bootstrap/app.php.

Set Custom Global Stack

->withMiddleware(function (Middleware $middleware) {
    $middleware->use([
        \Illuminate\Foundation\Http\Middleware\InvokeDeferredCallbacks::class,
        \Illuminate\Http\Middleware\TrustProxies::class,
        \Illuminate\Http\Middleware\HandleCors::class,
        \Illuminate\Foundation\Http\Middleware\PreventRequestsDuringMaintenance::class,
        \Illuminate\Http\Middleware\ValidatePostSize::class,
        \Illuminate\Foundation\Http\Middleware\TrimStrings::class,
        \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
        // Add your custom global middleware here
    ]);
});

Replace Middleware

$middleware->web(replace: [
    \Illuminate\Session\Middleware\StartSession::class => \App\Http\Middleware\CustomSessionHandler::class,
]);

Remove Middleware

$middleware->web(remove: [
    \Illuminate\Foundation\Http\Middleware\VerifyCsrfToken::class,
]);

Best Practices for Middleware

Maintain a clear execution order
Keep middleware single-purpose
Group related middleware logically
Optimize for performance
Handle exceptions gracefully
Test middleware chains thoroughly

Conclusion

Understanding and controlling middleware execution in Laravel 12 is essential for scalable, secure applications. Whether you’re handling authentication, localization, or tenant logic, middleware gives you both flexibility and power.

Mastering the priority() method, parameterized middleware, and terminable middleware will help you build more robust, predictable applications.

A well-designed middleware strategy leads to cleaner code, better performance, and fewer bugs.

Writing Your Own Eloquent Builder in Laravel

Asfia Aiman — Fri, 21 Mar 2025 05:17:57 +0000

Laravel's Eloquent ORM provides a powerful and intuitive interface for interacting with your database. While the built-in query builder offers extensive functionality, you may find yourself needing more specialized query logic that aligns with your application's domain. This is where custom Eloquent Builders come in.

What is a Custom Eloquent Builder?

A custom Eloquent Builder is an extension of Laravel's base Eloquent Builder that allows you to define reusable query logic specific to a particular model. It provides a way to encapsulate complex queries and create a fluent, readable API for querying your data.

Why Create Custom Eloquent Builders?

Code Organization and Maintainability

As your application grows, models can become bloated with numerous query scopes. Moving these to a dedicated builder class keeps your models lean and focused on their primary responsibility: representing data.

Reusability

Custom builders allow you to define query logic once and reuse it throughout your application, eliminating code duplication and ensuring consistency.

Readability

Well-named builder methods create self-documenting code. A method chain like User::active()->verified()->recentlyActive()->get() clearly communicates the query's intent.

Domain-Specific Queries

Custom builders let you create a query vocabulary that matches your domain, making your code more expressive and aligned with your business logic.

When to Implement Custom Builders

Consider creating a custom Eloquent Builder when:

Your model has too many query scopes

If your model file is dominated by scope methods (scopeActive(), scopeVerified(), etc.), it's time to refactor.
You repeat the same query patterns

When you find yourself writing identical query logic in multiple controllers or services.
Your queries reflect complex domain concepts

When queries represent sophisticated business rules or domain-specific filtering.
Query logic is becoming difficult to test

When testing query logic in controllers becomes cumbersome.
You need to standardize query patterns across a team

To ensure consistent data access patterns across different parts of your application.

Signs You Need a Custom Builder

You'll know it's time to implement a custom builder when:

Your model class exceeds 200-300 lines with many of those being query-related methods
You find yourself copying and pasting query conditions across controllers
You struggle to understand what a complex query is trying to accomplish
Different team members write inconsistent queries for the same data needs
You frequently need to update the same query logic in multiple places

How to Create a Custom Eloquent Builder

1. Create Your Builder Class

First, create a dedicated directory for your builders. A common convention is to place them in App\Models\Builders:

<?php

namespace App\Models\Builders;

use Illuminate\Database\Eloquent\Builder;

class PostBuilder extends Builder
{
    /**
     * Get only published posts.
     *
     * @return \App\Models\Builders\PostBuilder
     */
    public function published()
    {
        return $this->where('status', 'published');
    }

    /**
     * Get posts with high view counts.
     *
     * @param int $threshold
     * @return \App\Models\Builders\PostBuilder
     */
    public function popular(int $threshold = 1000)
    {
        return $this->where('views', '>', $threshold);
    }

    /**
     * Order posts with newest first.
     *
     * @return \App\Models\Builders\PostBuilder
     */
    public function recentFirst()
    {
        return $this->orderBy('created_at', 'desc');
    }

    /**
     * Filter posts by specific tag.
     *
     * @param string $tag
     * @return \App\Models\Builders\PostBuilder
     */
    public function withTag(string $tag)
    {
        return $this->whereHas('tags', function ($query) use ($tag) {
            $query->where('name', $tag);
        });
    }
}

2. Connect the Builder to Your Model

Override the newEloquentBuilder method in your model to use your custom builder:

<?php

namespace App\Models;

use App\Models\Builders\PostBuilder;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * Create a new Eloquent query builder for the model.
     *
     * @param \Illuminate\Database\Query\Builder $query
     * @return \App\Models\Builders\PostBuilder
     */
    public function newEloquentBuilder($query)
    {
        return new PostBuilder($query);
    }

    // Rest of your model...
}

3. Use Your Custom Builder

Now you can use your custom query methods directly on your model:

// Find popular, recently published posts about Laravel
$posts = Post::published()
    ->popular()
    ->withTag('laravel')
    ->recentFirst()
    ->get();

Real-World Example

Let's look at a practical example to illustrate when and how to implement a custom builder.

Before Custom Builder

Consider an e-commerce application where product filtering is complex:

// In a controller
$products = Product::where('active', true)
    ->where('stock', '>', 0)
    ->when($request->has('category'), function ($query) use ($request) {
        return $query->where('category_id', $request->category);
    })
    ->when($request->has('price_min'), function ($query) use ($request) {
        return $query->where('price', '>=', $request->price_min);
    })
    ->when($request->has('price_max'), function ($query) use ($request) {
        return $query->where('price', '<=', $request->price_max);
    })
    ->when($request->has('sort'), function ($query) use ($request) {
        if ($request->sort === 'price_asc') {
            return $query->orderBy('price', 'asc');
        } elseif ($request->sort === 'price_desc') {
            return $query->orderBy('price', 'desc');
        } elseif ($request->sort === 'newest') {
            return $query->orderBy('created_at', 'desc');
        }
        return $query;
    })
    ->paginate(20);

This code is hard to read, difficult to test, and would need to be duplicated in other controllers that need similar filtering.

After Custom Builder

With a custom builder:

// ProductBuilder.php
namespace App\Models\Builders;

use Illuminate\Database\Eloquent\Builder;

class ProductBuilder extends Builder
{
    public function active()
    {
        return $this->where('active', true);
    }

    public function inStock()
    {
        return $this->where('stock', '>', 0);
    }

    public function inCategory($categoryId)
    {
        return $this->where('category_id', $categoryId);
    }

    public function priceRange($min = null, $max = null)
    {
        return $this->when($min, function ($query) use ($min) {
                return $query->where('price', '>=', $min);
            })
            ->when($max, function ($query) use ($max) {
                return $query->where('price', '<=', $max);
            });
    }

    public function sortBy($sort)
    {
        return $this->when($sort === 'price_asc', function ($query) {
                return $query->orderBy('price', 'asc');
            })
            ->when($sort === 'price_desc', function ($query) {
                return $query->orderBy('price', 'desc');
            })
            ->when($sort === 'newest', function ($query) {
                return $query->orderBy('created_at', 'desc');
            });
    }
}

Now the controller becomes much cleaner:

// In a controller
$products = Product::active()
    ->inStock()
    ->when($request->has('category'), function ($query) use ($request) {
        return $query->inCategory($request->category);
    })
    ->priceRange($request->price_min, $request->price_max)
    ->sortBy($request->sort)
    ->paginate(20);

This approach offers several advantages:

The code is more readable and self-documenting
Query logic is reusable across controllers
Testing becomes easier since query methods can be tested in isolation
New filtering options can be added by extending the builder

Advanced Techniques

Combining Multiple Conditions

You can create methods that combine multiple conditions:

public function featuredAndDiscounted()
{
    return $this->where('is_featured', true)
                ->where('discount_percentage', '>', 0);
}

Parameterized Methods

Make your builder methods flexible with parameters:

public function olderThan($days)
{
    return $this->where('created_at', '<', now()->subDays($days));
}

Working with Relationships

Your builder methods can incorporate relationships:

public function withActiveReviews()
{
    return $this->whereHas('reviews', function ($query) {
        $query->where('status', 'approved');
    });
}

Handling Complex Logic

For very complex filtering, you can accept closures:

public function withAdvancedFilters($filterCallback)
{
    return $filterCallback($this);
}

Best Practices

Keep methods focused - Each method should handle a single aspect of filtering.
Use descriptive names - Method names should clearly describe their purpose.
Document with DocBlocks - Add PHPDoc comments to explain parameters and return values.
Return $this - Always return the builder instance for method chaining.
Write tests - Create unit tests for your builder methods to ensure they work as expected.

Conclusion

Custom Eloquent Builders are a powerful tool for organizing your query logic, making your code more maintainable, and creating a domain-specific query language for your application.

By identifying the right time to implement them—when models become bloated, queries are complex, or you need reusable query patterns—you can significantly improve your codebase's structure and readability.

Start small by identifying the most common query patterns in your application, move them to a custom builder, and gradually expand as you see the benefits of this approach. Your future self (and your team) will thank you for the clean, maintainable code that results from this architectural decision.

Mastering Conditional Logic in Laravel with `when()` and `unless()` Methods: Real-Life Examples

Asfia Aiman — Thu, 16 Jan 2025 06:32:55 +0000

Laravel is a powerful PHP framework known for its elegant syntax and robust features. One such feature introduced in Laravel 11.35.0 is the when() and unless() methods, part of the Conditionable trait. These methods provide a more readable, efficient way to handle conditional logic, improving the maintainability of your code. In this article, we’ll explore how to use these methods in real-life scenarios, demonstrating how they can streamline complex conditional logic in Laravel applications.

1. Dynamic Role Assignment Based on User Input

Imagine you’re building a user registration form where the user selects a role. Depending on the role, you want to assign different permissions or actions after creating the user.

Without `when()`:

if ($request->has('role')) {
    $user->assignRole($request->input('role'));
}

With `when()`:

$user->when($request->has('role'), function ($user) use ($request) {
    $user->assignRole($request->input('role'));
});

In this case, we only assign a role if the role input is present. The when() method makes it concise, and the block of code only executes when the condition is true.

2. Dynamic Validation Rules

Suppose you’re building a form where certain fields should only be validated if a specific condition is met. For example, the email field should only be required if the user selects the "newsletter" option.

Without `when()`:

$rules = [
    'email' => 'nullable',
];

if ($request->has('newsletter')) {
    $rules['email'] = 'required|email';
}

$request->validate($rules);

With `when()`:

$request->when($request->has('newsletter'), function () use ($request) {
    $request->validate([
        'email' => 'required|email',
    ]);
});

This is a cleaner and more readable way to apply conditional validation logic using when().

3. Conditional Data Merging for Specific Operations

In an e-commerce platform, you might want to apply a discount only if a specific coupon code is provided. Let's merge the discount data dynamically based on whether the coupon exists.

Without `when()`:

$data = [
    'total_price' => $cart->totalPrice(),
];

if ($request->has('coupon_code')) {
    $coupon = Coupon::where('code', $request->input('coupon_code'))->first();
    if ($coupon) {
        $data['discount'] = $coupon->discount_amount;
    }
}

return response()->json($data);

With `when()`:

$data = [
    'total_price' => $cart->totalPrice(),
];

$data = $data->when($request->has('coupon_code'), function ($data) use ($request) {
    $coupon = Coupon::where('code', $request->input('coupon_code'))->first();
    if ($coupon) {
        $data['discount'] = $coupon->discount_amount;
    }
    return $data;
});

return response()->json($data);

Here, we apply a conditional discount based on the coupon code in a more streamlined and chainable way.

4. Simplifying Conditional Logic for User Status

Let’s say you have a system where you want to send a different message depending on whether a user is active or inactive.

Without `unless()`:

if (!$user->isActive()) {
    return "Your account is inactive. Please contact support.";
} else {
    return "Welcome back!";
}

With `unless()`:

return $user->unless($user->isActive(), function () {
    return "Your account is inactive. Please contact support.";
})->otherwise(function () {
    return "Welcome back!";
});

Using unless() here helps condense the conditional logic into a single return statement.

5. Combining `when()` and `unless()` for Complex Flows

You can also combine when() and unless() for more complex conditional flows. For example, handling different user types (admin, guest, etc.) and showing them specific content.

$variable->when($user->isAdmin(), function ($variable) {
    return $variable->adminDashboard();
})->unless($user->isAdmin(), function ($variable) {
    return $variable->guestDashboard();
});

6. Payment Gateway Integration Based on User's Payment Method

Imagine you’re implementing a payment system where the payment method chosen by the user determines the flow of execution, such as whether to use a credit card, PayPal, or Bitcoin.

Without `when()`:

if ($request->input('payment_method') == 'credit_card') {
    // Handle credit card payment logic
} elseif ($request->input('payment_method') == 'paypal') {
    // Handle PayPal payment logic
} elseif ($request->input('payment_method') == 'bitcoin') {
    // Handle Bitcoin payment logic
}

With `when()`:

$request->when($request->input('payment_method') == 'credit_card', function () {
    // Handle credit card payment logic
})->when($request->input('payment_method') == 'paypal', function () {
    // Handle PayPal payment logic
})->when($request->input('payment_method') == 'bitcoin', function () {
    // Handle Bitcoin payment logic
});

This makes your payment handling more readable and simplifies the conditional logic for payment method selection.

7. Real Estate Property Price Calculation with Discounts

For a real estate application, if a user is a first-time buyer or using a special promo code, you might apply a discount to the property price.

Without `when()`:

$price = $property->price;

if ($request->has('first_time_buyer')) {
    $price -= 5000; // Discount for first-time buyers
}

if ($request->has('promo_code')) {
    $promo = PromoCode::where('code', $request->input('promo_code'))->first();
    if ($promo) {
        $price -= $promo->discount;
    }
}

return response()->json(['price' => $price]);

With `when()`:

$price = $property->price;

$price = $price->when($request->has('first_time_buyer'), function ($price) {
    return $price - 5000; // Discount for first-time buyers
});

$price = $price->when($request->has('promo_code'), function ($price) use ($request) {
    $promo = PromoCode::where('code', $request->input('promo_code'))->first();
    return $promo ? $price - $promo->discount : $price;
});

return response()->json(['price' => $price]);

This way, the code for calculating the price is cleaner and easier to maintain.

8. Medical Appointments with Insurance Verification

In a medical app, an appointment's payment might depend on whether the user has insurance, and you may need to verify it if provided.

Without `when()`:

$payment = $appointment->cost;

if ($request->has('insurance_provider')) {
    $insurance = Insurance::where('provider', $request->input('insurance_provider'))->first();
    if ($insurance) {
        $payment -= $insurance->coverage;
    }
}

return response()->json(['payment' => $payment]);

With `when()`:

$payment = $appointment->cost;

$payment = $payment->when($request->has('insurance_provider'), function ($payment) use ($request) {
    $insurance = Insurance::where('provider', $request->input('insurance_provider'))->first();
    return $insurance ? $payment - $insurance->coverage : $payment;
});

return response()->json(['payment' => $payment]);

This approach simplifies checking for insurance coverage and reduces clutter.

9. Bitcoin Price Adjustment Based on Market Conditions

Imagine you're building an app that allows users to buy Bitcoin, and the price fluctuates based on market conditions. If the market is volatile, you might want to add a fee to the price.

Without `when()`:

$price = $bitcoin->currentPrice();

if ($market->isVolatile()) {
    $price += 100; // Add a volatility fee
}

return response()->json(['price' => $price]);

With `when()`:

$price = $bitcoin->currentPrice();

$price = $price->when($market->isVolatile(), function ($price) {
    return $price + 100; // Add a volatility fee
});

return response()->json(['price' => $price]);

This simplifies the logic of applying a fee based on market volatility.

10. Conditional Product Availability in an E-commerce Store

Suppose you are building an e-commerce platform where products can only be shipped within certain regions. You want to check whether the product is available for a customer's location.

Without `when()`:

$shippingFee = 0;

if ($customer->location == 'international') {
    $shippingFee = $product->internationalShippingFee();
} else {
    $shippingFee = $product->domesticShippingFee();
}

return response()->json(['shipping_fee' => $shippingFee]);

With `when()`:

$shippingFee = $product->domesticShippingFee();

$shippingFee = $shippingFee->when($customer->location == 'international', function ($shippingFee) use ($product) {
    return $product->internationalShippingFee();
});

return response()->json(['shipping_fee' => $shippingFee]);

The when() method simplifies the conditional logic for determining shipping fees based on the customer's location.

11. Medical Treatment Plan Based on Patient's Health Conditions

Consider a healthcare application that assigns a treatment plan based on the patient's diagnosed health conditions. If the patient has a chronic condition, a long-term treatment plan might be suggested.

Without `when()`:

$treatmentPlan = 'Standard Plan';

if ($patient->hasChronicCondition()) {
    $treatmentPlan = 'Chronic Care Plan';
}

return response()->json(['treatment_plan' => $treatmentPlan]);

With `when()`:

$treatmentPlan = 'Standard Plan';

$treatmentPlan = $treatmentPlan->when($patient->hasChronicCondition(), function ($treatmentPlan) {
    return 'Chronic Care Plan';
});

return response()->json(['treatment_plan' => $treatmentPlan]);

This approach helps streamline the decision-making logic and makes it easier to handle more conditions in the future.

These examples demonstrate how the when() and unless() methods can be applied across various domains like payments, Bitcoin, real estate, and healthcare, making your Laravel code more readable, maintainable, and elegant. By embracing these methods, you can write cleaner code and enhance the maintainability of your Laravel applications.

How to Handle Large Datasets in Laravel Without Running Out of Memory

Asfia Aiman — Fri, 15 Nov 2024 05:55:41 +0000

How to Handle Large Datasets in Laravel Without Running Out of Memory

When working with large amounts of data in Laravel, it's common to run into issues like your application running out of memory. This can happen when trying to load thousands (or even millions) of records into memory all at once. However, Laravel provides a few useful methods to help you process data in smaller chunks, which saves memory and makes your application run faster. In this post, we'll walk through how to use chunk(), chunkById(), and Lazy Collections to efficiently process large datasets in Laravel.

What is the `chunk()` Method?

The chunk() method in Laravel allows you to retrieve a small subset of records at a time instead of loading everything in one go. This method is helpful when you need to process a large number of records but want to avoid using too much memory.

Example: Using `chunk()` to Process Data in Batches

Let's say you have a table of Orders and you want to update each order's status to "processed". Instead of loading all the orders into memory at once, you can use chunk() to load 100 orders at a time and process them in smaller batches.

use App\Models\Order;

Order::chunk(100, function ($orders) {
    foreach ($orders as $order) {
        // Process each order
        $order->update(['status' => 'processed']);
    }
});

100 is the number of records you want to process at once.
The callback function will be called for each "chunk" of 100 records.
After processing the first 100, it will move on to the next batch, and so on.

Why Use `chunk()`?

Saves memory: Instead of loading all records at once, Laravel only loads a small set (100 in our example), keeping memory usage low.
Efficient processing: This makes it easier to work with large datasets without your app crashing or slowing down.

What is the `chunkById()` Method?

The chunkById() method is similar to chunk(), but it’s better when you are updating records while you process them. This method ensures that records are always retrieved in a consistent order by their id column, making it safer to update data without missing any records.

Example: Using `chunkById()` for Consistent Updates

Imagine you want to update the status of orders, but you also need to ensure that the order IDs are processed in order. Using chunkById() ensures that no orders are skipped or processed twice, even if you're updating them.

use App\Models\Order;

Order::chunkById(100, function ($orders) {
    foreach ($orders as $order) {
        // Update each order's status
        $order->update(['status' => 'processed']);
    }
}, 'id');

The chunkById(100) method ensures that records are retrieved in batches of 100, but only the orders with an id greater than the last batch are fetched. This prevents missing records.
'id' is the column used to determine the order in which records are processed.

Why Use `chunkById()`?

Consistency: When you're updating records while processing them, chunkById() helps keep the data consistent, preventing records from being skipped or processed twice.
Safe for large data updates: This is ideal when you are modifying records during the process, like updating their statuses.

Using Lazy Collections for One-by-One Processing

While chunk() and chunkById() process records in batches, Lazy Collections allow you to process records one by one. This is especially useful when you want to handle each record as it’s retrieved, without using up much memory.

Example: Using Lazy Collections

If you only need to process one record at a time, Lazy Collections can be a great option. Here’s an example where we process each Order record individually:

use App\Models\Order;

foreach (Order::lazy() as $order) {
    // Process each order one by one
    $order->update(['status' => 'processed']);
}

With lazy(), each Order is processed one at a time, without loading the entire dataset into memory.
This is helpful when you're dealing with very large datasets, as it doesn’t keep all the records in memory at once.

Why Use Lazy Collections?

Very low memory usage: Each record is processed as it’s retrieved, so the memory usage stays minimal.
Great for large datasets: If you need to process a huge number of records and want to avoid high memory usage, Lazy Collections are your best friend.

When to Use Which Method

Use chunk() when you want to process records in batches of a set size, like 100 or 200, but don’t need to worry about the order of the records.
Use chunkById() when you need to process records in batches but also need to ensure consistency when updating them. This method guarantees that no records are skipped or processed twice.
Use Lazy Collections when you need to process records one at a time and want to minimize memory usage.

Conclusion: Efficient Data Processing in Laravel

Laravel provides some very powerful tools for working with large datasets without running into memory issues. Here’s a quick recap of what we learned:

chunk(): Process records in small batches to save memory.
chunkById(): Process records in batches while ensuring consistency (great for updates).
Lazy Collections: Process records one at a time, perfect for huge datasets with minimal memory usage.

By using these methods, you can ensure your Laravel application handles large datasets efficiently, even when processing millions of records. These techniques are essential for building scalable applications that perform well, no matter how much data you need to handle.

YajraBox Laravel DataTables: Building a Tags Management System

Asfia Aiman — Fri, 25 Oct 2024 07:42:42 +0000

DataTables is a powerful jQuery plugin that allows you to create interactive and responsive tables in your web applications. With the Yajra DataTables package for Laravel, integrating this feature becomes seamless. In this tutorial, we will implement a DataTable for managing tags in a Laravel 11 application.

Installation

First, we need to install the Yajra DataTables package via Composer. Run the following command in your terminal:

composer require yajra/laravel-datatables-oracle:"^11.0"

Configuration

Next, you'll want to add the service provider to your application. Open config/app.php and add the following line to the providers array:

'providers' => [
    // ...
    Yajra\DataTables\DataTablesServiceProvider::class,
],

Afterward, publish the configuration and assets using the following Artisan command:

php artisan vendor:publish --tag=datatables

Creating the DataTable Class

Now, let’s create a DataTable class for managing tags. Execute the following command to create a new DataTable class:

php artisan make:datatable TagsDataTable

Next, open the newly created TagsDataTable.php file located in the app/DataTables directory and populate it with the following code:

<?php

namespace App\DataTables;

use App\Models\Tag;
use Illuminate\Database\Eloquent\Builder as QueryBuilder;
use Yajra\DataTables\EloquentDataTable;
use Yajra\DataTables\Html\Builder as HtmlBuilder;
use Yajra\DataTables\Html\Button;
use Yajra\DataTables\Html\Column;
use Yajra\DataTables\Services\DataTable;

class TagsDataTable extends DataTable
{
    public function dataTable(QueryBuilder $query): EloquentDataTable
    {
        return (new EloquentDataTable($query))
            ->addColumn('created_at', function ($tag) {
                return $tag->created_at->format('d-m-Y'); // Format date
            })
            ->addColumn('action', function ($tag) {
                return '
                    <div class="d-flex justify-content-center">
                        <a href="' . route('tags.edit', $tag->id) . '" class="text-success me-2">Edit</a>
                        <form action="' . route('tags.destroy', $tag->id) . '" method="POST" class="d-inline" onsubmit="return confirm(\'Are you sure you want to delete this tag?\');">
                            ' . csrf_field() . '
                            ' . method_field('DELETE') . '
                            <button type="submit" class="text-danger" style="border: none; background: none; cursor: pointer;">Delete</button>
                        </form>
                    </div>';
            })
            ->setRowId('id')
            ->rawColumns(['action']);
    }

    public function query(Tag $model): QueryBuilder
    {
        return Tag::query(); // Basic query for tags
    }

    public function html(): HtmlBuilder
    {
        return $this->builder()
                    ->setTableId('tags-table')
                    ->columns($this->getColumns())
                    ->minifiedAjax()
                    ->orderBy(1)
                    ->selectStyleSingle()
                    ->buttons([
                        Button::make('excel')->addClass('btn btn-primary'),
                        Button::make('csv')->addClass('btn btn-primary'),
                        Button::make('pdf')->addClass('btn btn-primary'),
                        Button::make('print')->addClass('btn btn-primary'),
                        Button::make('reset')->addClass('btn btn-secondary'),
                        Button::make('reload')->addClass('btn btn-secondary')
                    ]);
    }

    /**
     * Get the dataTable columns definition.
     */
    public function getColumns(): array
    {
        return [
            Column::computed('id')->title('ID')->addClass('text-center'),
            Column::computed('name')->title('Tag Name'),
            Column::computed('created_at')->title('Created At'),
            Column::computed('action')->title('Actions')->addClass('text-center'), // Center align actions
        ];
    }

    protected function filename(): string
    {
        return 'Tags_' . date('YmdHis');
    }
}

Explanation of the DataTable Class

dataTable() Method: This method defines how the data is presented, including formatting for dates and adding action buttons for editing and deleting tags.
query() Method: This method retrieves all tags from the database.
html() Method: This method sets up the DataTable's configuration, including the table ID, columns, and buttons for export.
getColumns() Method: This method defines the columns that will appear in the DataTable.

Integrating DataTable into Your Controller

Next, you will integrate the TagsDataTable class into your controller. Open your TagController.php and modify the index method to utilize the DataTable:

use App\DataTables\TagsDataTable;

public function index(TagsDataTable $dataTable)
{
    return $dataTable->render('tags.index'); // Adjust view path as necessary
}

Setting Up the Blade View

In your Blade view file (e.g., resources/views/tags/index.blade.php), add the following code to display the DataTable:

@extends('layouts.app')

@section('content')
<div class="py-12">
    <div class="max-w-7xl mx-auto sm:px-6 lg:px-8 space-y-6">
        <div class="p-4 sm:p-8 bg-white shadow sm:rounded-lg">
            <div class="">
                {{ $dataTable->table() }}
            </div>
        </div>
    </div>
</div>
@endsection

@section('scripts')
    {{ $dataTable->scripts() }}
@endsection

Explanation of the Blade View

{{ $dataTable->table() }}: Generates the HTML for the DataTable.
{{ $dataTable->scripts() }}: Includes the necessary JavaScript for DataTables functionality.

Conclusion

In this guide, we implemented YajraBox DataTables in Laravel 11 to manage tags effectively. By following the steps outlined, you can create an interactive and responsive DataTable that enhances your web application's user experience.

With Yajra DataTables, you can easily manage data presentation, search, sort, and paginate your records with minimal effort. Feel free to modify the example to suit your specific application needs.

If you have any questions or need further assistance, please leave a comment below! Happy coding!

Simplifying Localization in Laravel 11: New Number Methods Unveiled

Asfia Aiman — Mon, 21 Oct 2024 06:52:03 +0000

Laravel 11 has arrived, and with it come some exciting new features that make web development even more seamless. Among the standout additions are two methods in the Number facade: Number::defaultLocale() and Number::defaultCurrency(). These methods are designed to help you effortlessly manage localization and currency formatting in your applications, making them essential tools for developers targeting a global audience.

In this post, we'll explore these new methods, their practical applications, and why they are a game-changer for your Laravel projects.

Why Localization and Currency Matter

In a world where your users could be from any corner of the globe, handling localization and currency formatting properly is crucial. Here are a few reasons why:

Global Accessibility: Users expect apps to present content in their preferred language and currency.
Enhanced User Experience: Properly formatted numbers and currencies foster trust and improve user satisfaction.
Precision: Especially for eCommerce, displaying accurate pricing is key to professionalism and customer confidence.

With the new methods in Laravel 11, managing these aspects becomes a breeze!

Introducing the New Methods

Laravel 11 now includes two powerful methods within the Number facade:

Number::defaultLocale(): Fetches the default locale set for your application.
Number::defaultCurrency(): Retrieves the default currency configured in your app.

Let’s dive deeper into how to use these methods.

1. Getting the Default Locale: `Number::defaultLocale()`

The Number::defaultLocale() method allows you to retrieve the locale setting for your application, which influences how numbers, dates, and currencies are displayed.

Example:

use Number;

$locale = Number::defaultLocale();
echo $locale;  // Example output: "en_US"

Use Case

If you’re building an eCommerce platform serving users from various countries, you can utilize Number::defaultLocale() to format prices and numbers according to the user’s locale, enhancing the shopping experience.

2. Getting the Default Currency: `Number::defaultCurrency()`

The Number::defaultCurrency() method lets you retrieve the default currency for your application. This is particularly useful when dealing with pricing and financial transactions.

Example:

use Number;

$currency = Number::defaultCurrency();
echo $currency;  // Example output: "USD"

Use Case

For multi-currency applications, ensuring that users see prices in their local currency is essential. The Number::defaultCurrency() method helps present prices accurately, fostering a seamless user experience.

Configuring Locale and Currency in Laravel

While the new methods retrieve default values, you may need to set these defaults in your application. Here's how to configure them.

Setting Locale in `config/app.php`

To set your application’s default locale, add or update the locale key in your configuration:

'locale' => 'en_US',  // Adjust to your preferred locale

Setting Default Currency

Laravel doesn’t provide a built-in way to set a default currency, but you can easily create a custom configuration for it. Here’s how:

Create a new config file named config/currency.php.
Define your default currency like so:

return [
    'default' => 'USD',  // Change to your desired currency code
];

Now you can retrieve this value in your application:

use Number;

$currency = config('currency.default');
echo $currency;  // Output: "USD"

Why You’ll Love These New Features

Here are a few reasons to embrace these new methods in Laravel 11:

Simplified Localization: Fetch locale and currency settings dynamically, minimizing hardcoding and potential errors.
Streamlined Global Development: Building applications for a worldwide audience becomes straightforward with these tools.
Cleaner Code: Leverage these methods to keep your codebase DRY (Don't Repeat Yourself) and improve maintainability.

Conclusion

The addition of Number::defaultLocale() and Number::defaultCurrency() in Laravel 11 empowers developers to manage localization and currency formatting more effectively. Whether you’re building an international eCommerce platform, a SaaS application, or any project with a global user base, these features will enhance your development experience.

Key Takeaways:

Use Number::defaultLocale() to dynamically retrieve the appropriate locale for your application.
Use Number::defaultCurrency() to ensure users see prices in their preferred currency.
Proper localization enhances user experience and trust.

What do you think about these new features? How do you plan to implement them in your projects? Share your thoughts in the comments!

Understanding the Difference Between pluck() and select() in Laravel 11

Asfia Aiman — Mon, 14 Oct 2024 15:13:19 +0000

Laravel, one of the most popular PHP frameworks, provides a range of powerful methods for data manipulation. Among these, pluck() and select() are frequently used when dealing with collections. Although they may seem similar, they serve different purposes. In this article, we’ll explore the differences between these two methods, explain when to use each, and provide practical coding examples to demonstrate their usage in Laravel 11.

What is `pluck()`?

The pluck() method is designed to extract values from a single key in a collection. It’s particularly handy when you want to retrieve a specific attribute from a collection of arrays or objects.

Example of `pluck()`

Let’s say you have a collection of products, and you want to extract just the product names:

$collection = collect([
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
]);

// Pluck only the names of the products
$plucked = $collection->pluck('name');

$plucked->all();
// Output: ['Desk', 'Chair']

Additionally, you can use pluck() to assign custom keys to the resulting collection:

$plucked = $collection->pluck('name', 'product_id');

$plucked->all();
// Output: ['prod-100' => 'Desk', 'prod-200' => 'Chair']

Nested Values with `pluck()`

The pluck() method also supports extracting nested values using dot notation:

$collection = collect([
    [
        'name' => 'Laracon',
        'speakers' => [
            'first_day' => ['Rosa', 'Judith'],
        ],
    ],
    [
        'name' => 'VueConf',
        'speakers' => [
            'first_day' => ['Abigail', 'Joey'],
        ],
    ],
]);

$plucked = $collection->pluck('speakers.first_day');

$plucked->all();
// Output: [['Rosa', 'Judith'], ['Abigail', 'Joey']]

Handling Duplicates

When dealing with collections that have duplicate keys, pluck() will use the last value associated with each key:

$collection = collect([
    ['brand' => 'Tesla',  'color' => 'red'],
    ['brand' => 'Pagani', 'color' => 'white'],
    ['brand' => 'Tesla',  'color' => 'black'],
    ['brand' => 'Pagani', 'color' => 'orange'],
]);

$plucked = $collection->pluck('color', 'brand');

$plucked->all();
// Output: ['Tesla' => 'black', 'Pagani' => 'orange']

What is `select()`?

The select() method in Laravel is more akin to SQL’s SELECT statement, allowing you to choose multiple keys from the collection and return only those keys as a new collection.

Example of `select()`

Let’s consider a collection of users where you want to retrieve both the names and roles:

$users = collect([
    ['name' => 'Taylor Otwell', 'role' => 'Developer', 'status' => 'active'],
    ['name' => 'Victoria Faith', 'role' => 'Researcher', 'status' => 'active'],
]);

$selectedUsers = $users->select(['name', 'role']);

$selectedUsers->all();
// Output: [
//     ['name' => 'Taylor Otwell', 'role' => 'Developer'],
//     ['name' => 'Victoria Faith', 'role' => 'Researcher'],
// ]

With select(), you can pull multiple attributes from the collection in one go.

Key Differences Between `pluck()` and `select()`

Purpose:
- pluck() is used to extract a single attribute or key-value pairs from a collection.
- select() is used to retrieve multiple attributes from each item in the collection, similar to an SQL query.
Return Structure:
- pluck() returns a flat array of values or an associative array when a second key is provided.
- select() returns a collection of arrays containing only the specified keys.
Usage:
- Use pluck() when you need a list of values from a specific key.
- Use select() when you need multiple fields from each element in the collection.

When to Use Which?

Use pluck() when:
- You need to extract values from a single key.
- You’re dealing with nested data and want to retrieve specific nested attributes.
Use select() when:
- You need to retrieve multiple keys or attributes.
- You want to restructure the data to focus on certain fields.

Conclusion

In Laravel 11, both pluck() and select() offer flexible ways to manipulate collections. While pluck() simplifies extracting single attributes, select() gives you more control when you need to work with multiple attributes. Knowing the differences between these two methods allows you to optimize your data manipulation processes and write cleaner, more efficient code.

By mastering both pluck() and select(), you can handle complex data structures with ease in your Laravel applications. Happy coding!

Understanding Self-Relationships in Laravel Models: A Simple Guide

Asfia Aiman — Tue, 24 Sep 2024 10:52:10 +0000

In Laravel, relationships between models are essential for organizing and working with connected data. Usually, we define relationships between different models, such as between a User model and a Post model (e.g., a user can have many posts). However, sometimes we need to create a relationship where a model is related to itself. This is called a self-referential relationship or self-relationship.

Now, let me explain why we would need a relationship like this, using simple, real-world examples and code snippets along the way.

1. What Is a Self-Relationship?

A self-relationship occurs when an object can be related to another object of the same kind. Imagine you're managing an organization where each employee has a manager. But the manager is also an employee! In this case, you need to connect employees to other employees, which means creating a relationship between instances of the same model.

Real-world Example: Employees and Managers

An employee might have a manager who is also an employee.
This relationship means an employee can "belong to" another employee (their manager), and at the same time, an employee can "have" other employees (subordinates).

2. Why Do We Need Self-Relationships?

Self-relationships are useful in situations where data needs to reference other data of the same type. Some common scenarios include:

Employee hierarchy: An employee reports to a manager who is also an employee.
Categories: Categories might have subcategories. For example, a "Programming" category might have subcategories like "Web Development" and "Data Science."
Friends: In a social network, a user might have friends who are also users.

3. Coding Example: Employee-Manager Relationship

Let’s break it down into code using a common example: employees and managers.

Step 1: Create the `Employee` Model and Migration

First, we need a model for our employees. In Laravel, we create this with a migration to define the table structure:

php artisan make:model Employee -m

This command creates both the Employee model and its corresponding migration file.

Step 2: Define the Migration

Next, we define our table structure. Here, we'll need a column for the employee’s details, as well as a column (manager_id) to store the ID of the employee’s manager (who is also an employee).

In the migration file (e.g., 2024_09_24_000000_create_employees_table.php), define the structure like this:

Schema::create('employees', function (Blueprint $table) {
    $table->id(); // Employee ID
    $table->string('name'); // Employee name
    $table->foreignId('manager_id')->nullable()->constrained('employees'); // Self-referencing
    $table->timestamps();
});

The manager_id field is a foreign key that points to the id of the same employees table. This is how we create a self-referential relationship.
It’s nullable because some employees might not have a manager (e.g., the CEO).

Run the migration to create the table:

php artisan migrate

Step 3: Define the Self-Relationship in the `Employee` Model

Next, we define the relationships within the Employee model itself.

In the Employee.php model file:

class Employee extends Model
{
    protected $fillable = ['name', 'manager_id'];

    // An employee belongs to a manager (who is also an employee)
    public function manager()
    {
        return $this->belongsTo(Employee::class, 'manager_id');
    }

    // An employee can have many subordinates (other employees)
    public function subordinates()
    {
        return $this->hasMany(Employee::class, 'manager_id');
    }
}

Here’s what we did:

manager(): This method defines that an employee belongs to a manager.
subordinates(): This method defines that an employee can have many subordinates.

4. Usage Example in Code

Now, let’s see how we can use these relationships in practice.

Add Some Employees

Let’s say we have three employees: Alice (the CEO), Bob (a manager), and Charlie (an employee reporting to Bob).

You can add them like this:

// Creating Alice (CEO, no manager)
$alice = Employee::create(['name' => 'Alice']);

// Creating Bob, who reports to Alice
$bob = Employee::create(['name' => 'Bob', 'manager_id' => $alice->id]);

// Creating Charlie, who reports to Bob
$charlie = Employee::create(['name' => 'Charlie', 'manager_id' => $bob->id]);

Query the Relationships

Get Bob’s manager:

$bob = Employee::where('name', 'Bob')->first();
echo $bob->manager->name; // Outputs "Alice"

Get Alice’s subordinates:

$alice = Employee::where('name', 'Alice')->first();
foreach ($alice->subordinates as $subordinate) {
    echo $subordinate->name; // Outputs "Bob"
}

Get Bob’s subordinates:

$bob = Employee::where('name', 'Bob')->first();
foreach ($bob->subordinates as $subordinate) {
    echo $subordinate->name; // Outputs "Charlie"
}

5. Practical Use Cases for Self-Relationships

Categories and Subcategories

Another example is categories and subcategories. You can create a self-referencing Category model, where each category can have subcategories.

class Category extends Model
{
    public function parentCategory()
    {
        return $this->belongsTo(Category::class, 'parent_id');
    }

    public function subCategories()
    {
        return $this->hasMany(Category::class, 'parent_id');
    }
}

This would allow you to model a system where categories are nested, such as:

Electronics
- Laptops
- Smartphones

You can query parent categories and subcategories in a similar way to the employee example.

Social Networks: Friends

In a social networking app, users might have other users as friends. You can model this with a self-relationship on the User model.

class User extends Model
{
    public function friends()
    {
        return $this->belongsToMany(User::class, 'user_friend', 'user_id', 'friend_id');
    }
}

This allows each user to have a list of friends who are also users.

Conclusion

Self-referential relationships are a powerful feature in Laravel for situations where data is related to other data of the same type. Whether you're modeling employee-manager hierarchies, category-subcategory structures, or friendships, self-relationships allow you to handle these kinds of relationships cleanly and efficiently.

By creating relationships to the same model, you can keep your data organized and easily query hierarchical or connected information with a few simple lines of code. Whether you're building an organizational chart, a category tree, or a social network, self-relationships in Laravel provide the flexibility you need.

How to Paginate Multiple Lists on the Same Blade File in Laravel 11 with Bootstrap 5 and Tailwind CSS

Asfia Aiman — Thu, 19 Sep 2024 07:13:43 +0000

Managing pagination is crucial when handling large datasets in modern web applications. In Laravel 11, you can effortlessly paginate data with built-in functionality. But what if you need to paginate multiple lists on the same Blade template? This tutorial will walk you through how to do exactly that using Bootstrap 5 and Tailwind CSS for styling.

In this guide, you’ll learn how to:

Implement independent pagination for multiple datasets.
Style pagination links with both Bootstrap 5 and Tailwind CSS.
Preserve the state of paginated lists when switching between pages.

Let’s dive into the details!

Why Paginate Multiple Lists?

In many applications, you might need to display more than one list of data, such as users, products, or posts, each with their own independent pagination. For example, in a dashboard or admin panel, you might have paginated lists for users, orders, and products. Laravel makes it simple to achieve this while maintaining clean URLs and easy navigation.

Setting Up Laravel 11

Before we begin, ensure that you have a Laravel 11 project set up. If you need to create a new project, run the following command:

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

Creating a Controller to Handle Multiple Paginated Lists

For this example, assume we have two models: User and Product. We’ll fetch paginated results for both in a controller and display them in a Blade template.

Start by creating a controller:

php artisan make:controller DashboardController

In the DashboardController, we’ll implement pagination for both users and products:

<?php

namespace App\Http\Controllers;

use App\Models\User;
use App\Models\Product;
use Illuminate\Http\Request;

class DashboardController extends Controller
{
    public function index(Request $request)
    {
        // Paginate users with 10 records per page
        $users = User::orderBy('name_of_firm')->paginate(10, ['*'], 'agents');

        // Paginate products with 10 records per page
        $products = Product::orderBy('name')->paginate(10, ['*'], 'products');

        // Pass the paginated data to the view
        return view('dashboard', compact('users', 'products'));
    }
}

Here, we’ve used different pagination query strings (agents for users and products for products) to ensure that they don’t interfere with each other.

Displaying Paginated Lists in Blade

Now, let’s create a Blade file (resources/views/dashboard.blade.php) to display the paginated lists:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dashboard</title>
    <!-- Bootstrap 5 CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    <!-- Tailwind CSS -->
    <link href="https://cdn.jsdelivr.net/npm/tailwindcss@3.3.0/dist/tailwind.min.css" rel="stylesheet">
</head>
<body>
    <div class="container mt-4">

        <!-- Users List -->
        <h2 class="text-2xl font-bold mb-4">Users List</h2>
        <ul class="list-group mb-4">
            @foreach ($users as $user)
                <li class="list-group-item">{{ $user->name_of_firm }}</li>
            @endforeach
        </ul>
        {{ $users->appends(['products' => $products->currentPage()])->links('pagination::bootstrap-5') }}

        <!-- Products List -->
        <h2 class="text-2xl font-bold mb-4">Products List</h2>
        <ul class="list-group mb-4">
            @foreach ($products as $product)
                <li class="list-group-item">{{ $product->name }}</li>
            @endforeach
        </ul>
        {{ $products->appends(['agents' => $users->currentPage()])->links('pagination::bootstrap-5') }}

    </div>

    <!-- Bootstrap 5 JS -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

In this example:

We use appends() to preserve the current page number of each list when navigating between paginated results.
Bootstrap 5 is used to style the pagination links, and you can easily swap it for Tailwind CSS.

Adding Tailwind CSS Pagination Styling

Laravel supports custom pagination views, making it easy to use Tailwind CSS for styling if needed. First, create a custom Tailwind pagination view:

mkdir -p resources/views/vendor/pagination
touch resources/views/vendor/pagination/tailwind.blade.php

In tailwind.blade.php, you can define the pagination layout using Tailwind’s utility classes:

@if ($paginator->hasPages())
    <nav role="navigation" aria-label="Pagination Navigation" class="flex justify-between">
        {{-- Previous Page Link --}}
        @if ($paginator->onFirstPage())
            <span class="disabled">«</span>
        @else
            <a href="{{ $paginator->previousPageUrl() }}" class="text-blue-500">«</a>
        @endif

        {{-- Pagination Elements --}}
        @foreach ($elements as $element)
            @if (is_string($element))
                <span class="disabled">{{ $element }}</span>
            @endif

            @if (is_array($element))
                @foreach ($element as $page => $url)
                    @if ($page == $paginator->currentPage())
                        <span class="font-bold">{{ $page }}</span>
                    @else
                        <a href="{{ $url }}" class="text-blue-500">{{ $page }}</a>
                    @endif
                @endforeach
            @endif
        @endforeach

        {{-- Next Page Link --}}
        @if ($paginator->hasMorePages())
            <a href="{{ $paginator->nextPageUrl() }}" class="text-blue-500">»</a>
        @else
            <span class="disabled">»</span>
        @endif
    </nav>
@endif

In your Blade file, switch to Tailwind pagination:

{{ $users->links('pagination::tailwind') }}

This will render the pagination links using Tailwind CSS styling.

Conclusion

Paginating multiple lists on the same Blade file in Laravel 11 can be accomplished by using independent query string parameters and customizing the pagination view for different styling needs. Whether you choose Bootstrap 5 or Tailwind CSS for styling, Laravel's pagination tools make it easy to handle large datasets with elegance and simplicity.

Handling Enum Values in Laravel Blade Templates

Asfia Aiman — Tue, 17 Sep 2024 16:58:52 +0000

Enums in Laravel offer a structured way to represent a set of constant values. However, when it comes to working with enums in Blade templates, things can sometimes become unclear, especially when comparing values for conditional rendering. In this article, I will walk you through the correct approach for handling enum values in Blade templates, helping you avoid common pitfalls.

Understanding the Challenge

Laravel enums are a powerful tool for defining specific states or categories. For instance, you might define different user types such as 'admin', 'agent', or 'agency'. However, when you attempt to compare these enum values in Blade templates, you may encounter unexpected results.

A common scenario might involve conditionally rendering a navigation menu based on the user's role. If you directly compare an enum object with a string in Blade, the result will likely fail due to the nature of enums being objects rather than primitive values.

The Correct Approach

Laravel enums encapsulate both value and additional functionality, which means a direct comparison may not work as intended. To compare enum values in Blade templates, you should reference the value property.

Here’s an example demonstrating the solution.

Example: Comparing Enum Values

Suppose you have an enum class UserType for different user roles in your application:

<?php

namespace App\Enums;

enum UserType: string {
    case Admin = 'admin';
    case Agent = 'agent';
    case Agency = 'agency';
}

In this scenario, let's say you want to show specific navigation items for users with the roles of 'agent' or 'agency'.

Incorrect Comparison

A direct comparison of enums in Blade templates might look like this, but it won’t work:

@if (auth()->user()->user_type === 'agent' || auth()->user()->user_type === 'agency')
    <!-- Navigation items for agents and agencies -->
@endif

The above code fails because auth()->user()->user_type returns an enum object, not a string. Comparing it with a string will always result in false.

Correct Comparison: Accessing the value Property

The correct way to compare enum values in Blade is by accessing the value property of the enum:

@if (auth()->user()->user_type->value === 'agent' || auth()->user()->user_type->value === 'agency')
    <!-- Navigation items for agents and agencies -->
@endif

Here, we’re extracting the raw value ('agent' or 'agency') from the enum object, which allows for a proper comparison.

Refactoring for Readability

If you need to check the enum value in multiple parts of your Blade templates, consider defining a helper function or a method in your model to streamline this:

In the User Model:

public function isAgentOrAgency(): bool {
    return $this->user_type->value === 'agent' || $this->user_type->value === 'agency';
}

In the Blade Template:

@if (auth()->user()->isAgentOrAgency())
    <!-- Navigation items for agents and agencies -->
@endif

This approach improves readability and reduces repetitive code.

Leveraging Enums in Other Parts of Laravel

Enums are not only useful in Blade templates; they can be leveraged across your entire Laravel application for more structured and predictable logic. You can use them in:

1. Validation Rules:
Use enums to define acceptable values.

'user_type' => ['required', Rule::in(UserType::cases())],

2. Database Queries:
Compare enums in query conditions.

$users = User::where('user_type', UserType::Agent->value)->get();

By understanding and correctly implementing enums, you ensure your application’s logic is more robust and future-proof.

Key Takeaways

- Enum Values are Objects:
Always access the value property when comparing enums in Blade templates.

- Centralize Logic:
Define helper methods or refactor comparison logic to improve code readability and maintainability.

- Enums Across the Application:
Use enums in database queries, validation rules, and more for predictable code.

Enums in Laravel offer significant advantages when used properly, particularly when it comes to maintaining clean and readable code. By ensuring that Blade template comparisons are done correctly, you can prevent unnecessary bugs and enjoy the benefits of enums across your application.

Conclusion

Handling enums in Blade templates requires understanding how Laravel structures these objects. With the correct approach of accessing the value property, you can easily integrate enum comparisons into your views and make your application logic clearer and more maintainable.

A Beginner’s Guide to Constructor Property Promotion in PHP

Asfia Aiman — Sat, 24 Aug 2024 14:45:31 +0000

PHP 8 introduced a fantastic feature called Constructor Property Promotion. If you're new to PHP or programming in general, this might sound a bit complex. But don’t worry! This blog will walk you through what it is, why it's useful, and how you can use it with plenty of coding examples. Let’s get started!

What is Constructor Property Promotion?

Before PHP 8, creating a class with properties and initializing them in a constructor required quite a bit of repetitive code. With Constructor Property Promotion, PHP 8 simplifies this process by letting you declare and initialize class properties directly in the constructor parameters.

Why Should You Care?

Constructor Property Promotion isn’t just about saving a few lines of code—it’s about making your code cleaner, easier to read, and simpler to maintain. This is especially valuable for beginners who might find the traditional way of writing constructors a bit daunting.

Traditional Way vs. Constructor Property Promotion

Let’s start by comparing the traditional way of writing classes and constructors with the new way introduced in PHP 8.

Before PHP 8 (Traditional Way)

class Car {
    public string $make;
    public string $model;
    public int $year;

    public function __construct(string $make, string $model, int $year) {
        $this->make = $make;
        $this->model = $model;
        $this->year = $year;
    }
}

$car = new Car('Toyota', 'Corolla', 2020);

In this example, we have to declare the properties ($make, $model, and $year) and then assign them inside the constructor. It’s a lot of repetition, especially when dealing with classes that have many properties.

With PHP 8 (Constructor Property Promotion)

class Car {
    public function __construct(
        public string $make,
        public string $model,
        public int $year
    ) {}
}

$car = new Car('Toyota', 'Corolla', 2020);

With Constructor Property Promotion, you declare and assign the properties in the constructor parameters. The result is a more concise and readable class definition.

More Coding Examples

To fully understand the power of Constructor Property Promotion, let’s explore more examples in different scenarios.

Example 1: Defining a Book Class

class Book {
    public function __construct(
        public string $title,
        public string $author,
        public int $pages,
        public bool $isAvailable = true
    ) {}
}

$book = new Book('1984', 'George Orwell', 328);
echo $book->title; // Output: 1984
echo $book->isAvailable; // Output: 1 (true)

In this Book class, the isAvailable property has a default value of true. If you don't specify this parameter when creating an instance of the class, it will automatically be set to true.

Example 2: Creating an Order Class

class Order {
    public function __construct(
        public int $orderId,
        public string $product,
        public float $price,
        public string $status = 'pending'
    ) {}
}

$order = new Order(123, 'Laptop', 999.99);
echo $order->status; // Output: pending

$order2 = new Order(124, 'Smartphone', 599.99, 'shipped');
echo $order2->status; // Output: shipped

Here, the Order class includes a status property with a default value of pending. However, you can override this value by providing a different status when creating the order.

Example 3: Building a User Profile Class

class UserProfile {
    public function __construct(
        public string $username,
        public string $email,
        public int $age,
        private string $password,
        protected string $role = 'user'
    ) {}

    public function getPassword(): string {
        return $this->password;
    }
}

$userProfile = new UserProfile('johndoe', 'john@example.com', 25, 'secret');
echo $userProfile->username; // Output: johndoe
echo $userProfile->getPassword(); // Output: secret
echo $userProfile->role; // Error: Cannot access protected property

In the UserProfile class, the password property is private, meaning it can’t be accessed directly outside the class. Instead, you use the getPassword() method to retrieve it. The role property is protected, so it can be accessed only within the class itself or by subclasses.

Example 4: A Product Class with Constructor Property Promotion

class Product {
    public function __construct(
        public string $name,
        public float $price,
        public int $stock = 0
    ) {}
}

$product = new Product('Laptop', 999.99, 10);
echo $product->name; // Output: Laptop
echo $product->stock; // Output: 10

This example shows how you can use Constructor Property Promotion to create a Product class that includes a default value for the stock property.

Benefits of Constructor Property Promotion

**Less Boilerplate Code: **You don’t need to write repetitive code to declare and initialize properties.
Increased Readability: The class definition is more concise and easier to understand at a glance.
Reduced Errors: By combining property declaration and initialization, there’s less room for mistakes.

Conclusion

Constructor Property Promotion in PHP 8 is a powerful feature that can significantly improve the way you write classes. By reducing boilerplate code, increasing readability, and making your code more maintainable, it’s a feature that both new and experienced developers will appreciate.

Whether you're building a small project or a large application, Constructor Property Promotion will help you write cleaner, more efficient PHP code. So go ahead, give it a try in your next project, and enjoy the benefits of this awesome feature!

DEV Community: Asfia Aiman

Mastering Scoped Resource Routes in Laravel: A Practical Guide

Understanding Scoped Implicit Model Binding

When to Use Scoped Resource Routes

Why Scoped Resource Routes Are a Good Idea

Example: Scoped Routes with Blogs and Posts

1. Define the Models

2. Create the Controller

3. Define the Routes

4. Create a View

5. Testing the Route

Advanced Example: Custom Relationship Name

Practical Use Case: Why It Matters

Conclusion

Mastering Middleware Execution Order in Laravel 12

Understanding Middleware Execution Order

Sorting Middleware in Laravel 12

When to Use Middleware Priority

Real-World Example: Multi-Tenant App

What Happens Without Proper Sorting?

Middleware Parameters

Example: Subscription Check

Usage

Class-Based Syntax

Multiple Parameters

Real-World Example: Age-Based Content Filtering

Usage

Terminable Middleware: After Response Hooks

Example: Page View Logger

Register as Singleton

Use Cases

Managing Laravel’s Global Middleware

Set Custom Global Stack

Replace Middleware

Remove Middleware

Best Practices for Middleware

Conclusion

Writing Your Own Eloquent Builder in Laravel

What is a Custom Eloquent Builder?

Why Create Custom Eloquent Builders?

Code Organization and Maintainability

Reusability

Readability

Domain-Specific Queries

When to Implement Custom Builders

Signs You Need a Custom Builder

How to Create a Custom Eloquent Builder

1. Create Your Builder Class

2. Connect the Builder to Your Model

3. Use Your Custom Builder

Real-World Example

Before Custom Builder

After Custom Builder

Advanced Techniques

Combining Multiple Conditions

Parameterized Methods

Working with Relationships

Handling Complex Logic

Best Practices

Conclusion

Mastering Conditional Logic in Laravel with `when()` and `unless()` Methods: Real-Life Examples

1. Dynamic Role Assignment Based on User Input

Without when():

With when():

2. Dynamic Validation Rules

Without when():

With when():

3. Conditional Data Merging for Specific Operations

Without when():

With when():

4. Simplifying Conditional Logic for User Status

Without unless():

With unless():

5. Combining when() and unless() for Complex Flows

6. Payment Gateway Integration Based on User's Payment Method

Without when():

With when():

7. Real Estate Property Price Calculation with Discounts

Without when():

With when():

Without `when()`:

With `when()`:

Without `when()`:

With `when()`:

Without `when()`:

With `when()`:

Without `unless()`:

With `unless()`:

5. Combining `when()` and `unless()` for Complex Flows

Without `when()`:

With `when()`:

Without `when()`:

With `when()`:

Without `when()`:

With `when()`:

Without `when()`:

With `when()`:

Without `when()`:

With `when()`:

Without `when()`:

With `when()`:

What is the `chunk()` Method?

Example: Using `chunk()` to Process Data in Batches

Why Use `chunk()`?

What is the `chunkById()` Method?

Example: Using `chunkById()` for Consistent Updates

Why Use `chunkById()`?

1. Getting the Default Locale: `Number::defaultLocale()`

2. Getting the Default Currency: `Number::defaultCurrency()`

Setting Locale in `config/app.php`

What is `pluck()`?

Example of `pluck()`

Nested Values with `pluck()`

What is `select()`?

Example of `select()`

Key Differences Between `pluck()` and `select()`

Step 1: Create the `Employee` Model and Migration

Step 3: Define the Self-Relationship in the `Employee` Model