This post is about how to navigate the waters of Laravel—an excellent PHP framework—and we’re going to focus on an interesting and essential feature: retrieving products from nested categories using a Many-to-Many relationship and ordering the result. So, if you’ve been grappling with this particular challenge, you’ve come to the right place. Let’s dive right in!
Understanding the Challenge
A user on StackOverflow recently faced an issue where they wanted to retrieve products of a selected category, including its sub-categories. Moreover, they needed to order the products according to price or date. As an example, if a user clicks on the ‘Phone’ category, all products belonging to ‘Phone’, ‘Samsung’, or ‘Nokia’ should appear. Their tables were structured in a many-to-many relationship using Laravel’s Eloquent ORM.
Now, how do you solve this puzzle? Let’s break it down.
The Laravel Solution
Setting up the Models
First, you need to have your models set up correctly. Here’s how you can define your models in Laravel:
class Category extends Model {
public function products() {
return $this->belongsToMany(‘App\Product’);
}
public function parent() {
return $this->belongsTo(‘App\Category’, ‘parent_id’);
}
public function children() {
return $this->hasMany(‘App\Category’, ‘parent_id’);
}
}
class Product extends Model {
public function categories() {
return $this->belongsToMany(‘App\Category’);
}
}
Tackling the Controller
Now, we’ll need to update the ProductController. Below, you’ll find the necessary changes to the controller:
class ProductController extends Controller {
public function index($slug, Request $request) {
// All the magic happens here
}
}
Remember to keep your code clean and modular. You never know when you might have to revisit it or when another developer might need to understand it.
Decoding the View
In the view, you’ll use the code below to sort the products and display them as per the category or sub-category selected:
{{ csrf_field() }} Sort By: Latest Price Low to High Price High to Low
@foreach($category->products as $product)
image)}}” alt=”{{$product->name}}”>
{{$product->name}}
${{$product->price}}
@endforeach
Voila! There you have it. Now you’re all set to retrieve products from a selected category along with its sub-categories and order them as per your needs.
Let’s Get Technical: Our Database Structure
Our ‘Products’ table includes ‘id’, ‘name’, ‘price’, and ‘created_at’ fields. The ‘Categories’ table has ‘id’, ‘name’, ‘slug’, ‘parent_id’, ‘sorting_order’, and ‘created_at’ fields. Lastly, the ‘category_product’ table includes ‘id’, ‘category_id’, and ‘product_id’ fields.
What’s Under the Hood: Our Models
In our Category model, we define a method ‘products()’ that establishes a Many-to-Many relationship with the Product model. Additionally, ‘parent()’ and ‘children()’ methods define the relationships between the categories and their respective parent and children categories.
The Heart of the Matter: Our Controller
This is where the magic happens. In our ProductController, we have an ‘index()’ function. This function accepts a slug and a Request as parameters. If the ‘sortBy’ key is not set in the query string, the function retrieves the category matching the provided slug, along with its associated products.
If the ‘sortBy’ key is indeed set, we determine the category based on the URL segment and sort the products accordingly: by creation date, price (ascending or descending), or simply return the products without sorting.
Recursive Relationships
When it comes to categories and sub-categories, Laravel provides a powerful tool for handling recursive relationships. In the Category model, we have the parent() and children() methods to manage these relationships. But retrieving products from these categories can be a bit challenging.
To retrieve products from a category and its sub-categories, we need to go through each sub-category recursively and fetch their products. This can be achieved by adding a method to the Category model to fetch all products.
<!-- Category Model -->
class Category extends Model {
// ... existing relationships ...
public function allProducts() {
$allProducts = $this->products;
foreach($this->children as $child) {
$allProducts = $allProducts->concat($child->allProducts());
}
return $allProducts;
}
}
This allProducts() method retrieves the products for the current category and iteratively fetches the products for its sub-categories.
In the ProductController, we can now access the products of a category including its sub-categories with $category->allProducts(). For instance:
class ProductController extends Controller {
public function index($slug, Request $request) {
$category = Category::where(‘slug’, $slug)->firstOrFail();
$products = $category->allProducts();
// sorting logic remains the same
}}
Ordering the Results
For the sorting part, you can add a condition check in your index method in the ProductController. Let’s take a look at how you can do this:
class ProductController extends Controller {
public function index($slug, Request $request) {
$category = Category::where(‘slug’, $slug)->firstOrFail();
$products = $category->allProducts();
$sortBy = $request->get('sortBy');
if($sortBy == 'latest') {
$products = $products->sortByDesc('created_at');
}
elseif($sortBy == 'asc') {
$products = $products->sortBy('price');
}
elseif($sortBy == 'desc') {
$products = $products->sortByDesc('price');
}
return view('products.index', compact('products'));
}}
Here, we’re checking the ‘sortBy’ value from the GET request and then sorting the products accordingly.
Pagination
Laravel provides simple, easy-to-use pagination of database results out of the box. However, when we’re using custom collections as we are doing with allProducts() method, we need to manually create a paginator.
First, you would need to import the Illuminate\Pagination\LengthAwarePaginator class to your ProductController.
Then, you can create a new paginate method in the ProductController:
public function paginate($items, $perPage = 15, $page = null, $options = [])
{
$page = $page ?: (Paginator::resolveCurrentPage() ?: 1);
$items = $items instanceof Collection ? $items : Collection::make($items);
return new LengthAwarePaginator($items->forPage($page, $perPage), $items->count(), $perPage, $page, $options);}
And, in your index method, you would use it like this:
public function index($slug, Request $request) {
$category = Category::where(‘slug’, $slug)->firstOrFail();
$products = $category->allProducts();
// your sorting logic here...
$products = $this->paginate($products);
return view('products.index', compact('products'));}
This will create a paginator for your products which you can then use in your views as you would with the standard Laravel paginator
Filtering
To add a simple filter, you could add another condition in your index method similar to the sort logic. For instance, to filter by price range:
public function index($slug, Request $request) {
$category = Category::where(‘slug’, $slug)->firstOrFail();
$products = $category->allProducts();
$minPrice = $request->get('minPrice');
$maxPrice = $request->get('maxPrice');
if ($minPrice && $maxPrice) {
$products = $products->filter(function($product) use ($minPrice, $maxPrice) {
return $product->price >= $minPrice && $product->price <= $maxPrice;
});
}
// your sorting logic here...
$products = $this->paginate($products);
return view('products.index', compact('products'));}
Conclusion
Laravel provides a very powerful and flexible framework for building web applications, including those with complex hierarchical data structures such as category-product relationships. You can use Eloquent relationships to represent these structures in your database, and Laravel’s query builder to fetch and manipulate the data. For complex operations, such as getting all products of a category and its subcategories, you can use recursive methods to traverse the hierarchy. Furthermore, Laravel provides built-in support for sorting, filtering, and paginating database results. Even when you’re using custom collections, Laravel provides tools that you can use to manually sort, filter, and paginate the results. However, always be mindful of the performance implications of complex operations, especially recursive calls, and consider optimizing your queries or using cache to improve performance. Always thoroughly test your application to ensure that it can handle the expected load. Finally, remember that programming is a craft, and there’s often more than one way to solve a problem. Always consider the trade-offs and choose the solution that best fits your particular use case and constraints.
