**Course Title:** Mastering Laravel Framework: Building Scalable Modern Web Applications **Section Title:** Advanced Eloquent: Scopes, Mutators, and Events **Topic:** Implement advanced Eloquent features like scopes and observers in a multi-model application.(Lab topic) In this lab topic, we will apply the advanced Eloquent concepts learned in the previous topics to a multi-model application. We will implement local and global scopes, accessors, mutators, and observers to create a robust and maintainable database interaction system. **Prerequisites** Before starting this lab topic, ensure that you have completed the previous topics in this course and have a good understanding of the following concepts: * Eloquent ORM * Relationships (one-to-one, one-to-many, many-to-many) * Query Builder vs. Eloquent ORM * Advanced Eloquent features (scopes, mutators, events) **Lab Overview** In this lab, we will work with a sample application that involves multiple models: `User`, `Order`, `Product`, and `Category`. We will implement the following advanced Eloquent features: * Local scopes: `scopeFilterByCategory` and `scopeFilterByPrice` * Global scopes: `HasCategoryScope` and `HasPriceScope` * Accessors: `getFormattedPrice` and `getCategoryName` * Mutators: `setFormattedPrice` and `setCategoryName` * Observers: `UserObserver` and `OrderObserver` **Step 1: Define Local Scopes** Local scopes are methods in your Eloquent model that allow you to scope a query to a specific set of results. In this step, we will define two local scopes: `scopeFilterByCategory` and `scopeFilterByPrice`. ```php // app/Models/Order.php public function scopeFilterByCategory($query, $category) { return $query->where('category_id', $category); } public function scopeFilterByPrice($query, $price) { return $query->where('price', '<=', $price); } ``` **Step 2: Define Global Scopes** Global scopes are methods that apply to all queries of a certain model. In this step, we will define two global scopes: `HasCategoryScope` and `HasPriceScope`. ```php // app/Scopes/HasCategoryScope.php namespace App\Scopes; use Illuminate\Database\Eloquent\Scope; use Illuminate\Database\Eloquent\Builder; class HasCategoryScope implements Scope { public function apply(Builder $builder, Model $model) { $builder->where('category_id', '!=', null); } } // app/Scopes/HasPriceScope.php namespace App\Scopes; use Illuminate\Database\Eloquent\Scope; use Illuminate\Database\Eloquent\Builder; class HasPriceScope implements Scope { public function apply(Builder $builder, Model $model) { $builder->where('price', '>', 0); } } ``` **Step 3: Apply Global Scopes** To apply global scopes, you need to register them in the `boot` method of the model. ```php // app/Models/Order.php protected static function booted() { static::addGlobalScope(new HasCategoryScope); static::addGlobalScope(new HasPriceScope); } ``` **Step 4: Define Accessors and Mutators** Accessors and mutators are methods that allow you to customize the way Eloquent interacts with your database. In this step, we will define two accessors and two mutators. ```php // app/Models/Product.php public function getFormattedPriceAttribute($value) { return number_format($value, 2); } public function setFormattedPriceAttribute($value) { $this->attributes['price'] = number_format($value, 2); } // app/Models/Order.php public function getCategoryNameAttribute() { return $this->category->name; } public function setCategoryNameAttribute($value) { $this->category_id = Category::where('name', $value)->first()->id; } ``` **Step 5: Define Observers** Observers are classes that allow you to listen for specific events on a model. In this step, we will define two observers: `UserObserver` and `OrderObserver`. ```php // app/Observers/UserObserver.php namespace App\Observers; use App\Models\User; use App\Models\Order; class UserObserver { public function saved(User $user) { // do something when user is saved } public function deleted(User $user) { // do something when user is deleted } } // app/Observers/OrderObserver.php namespace App\Observers; use App\Models\Order; class OrderObserver { public function saved(Order $order) { // do something when order is saved } public function deleted(Order $order) { // do something when order is deleted } } ``` **Conclusion** In this lab topic, we have applied advanced Eloquent features like local and global scopes, accessors, mutators, and observers to a multi-model application. We have seen how to customize the way Eloquent interacts with your database and how to listen for specific events on a model. By applying these concepts to your own applications, you will be able to create robust and maintainable database interaction systems. **External Resources** * [Laravel Eloquent documentation](https://laravel.com/docs/eloquent) * [Laravel scopes documentation](https://laravel.com/docs/scopes) * [Laravel accessors and mutators documentation](https://laravel.com/docs/accessors) * [Laravel observers documentation](https://laravel.com/docs/observers) **Leave a comment** If you have any questions or need further clarification on any of the concepts covered in this lab topic, please leave a comment below.