PHPackages                             holoyan/eloquent-filter - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Database & ORM](/categories/database)
4. /
5. holoyan/eloquent-filter

ActiveLibrary[Database & ORM](/categories/database)

holoyan/eloquent-filter
=======================

Eloquent filter for laravel models, easy and powerful

v1.2.0(4y ago)22.2k↓42.9%MITPHPPHP >=7.1

Since Jun 6Pushed 4y ago1 watchersCompare

[ Source](https://github.com/holoyan/eloquent-filter)[ Packagist](https://packagist.org/packages/holoyan/eloquent-filter)[ Docs](https://github.com/holoyan/eloquent-filter)[ RSS](/packages/holoyan-eloquent-filter/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (5)Dependencies (2)Versions (7)Used By (0)

Eloquent Filter
===============

[](#eloquent-filter)

Table of Content
----------------

[](#table-of-content)

- [Introduction](#introduction)
- [Requirement](#requirement)
- [Installation](#installation)
- [Basic Usage](#basic-usage)
    - [Dynamic filters](#dynamic-filter)
    - [Customize column](#customize-column)
    - [Customize value](#customize-value)
    - [Available filters](#available-filters)
- [Ordering](#ordering)
- [Relation Filter](#relation-filter)
- [Nested Filter](#nested-filter)
- [Extending filter](#extending-filter)
    - [Custom Rules](#custom-rules)
- [Credits](#credits)
- [License](#license)

Introduction
------------

[](#introduction)

An easy way to add custom filters to your eloquent models. Powerful, flexible and fully dynamic

```
 $users = User::filter($request->all())->get();
```

Requirement
-----------

[](#requirement)

PHP >= 7.1

Installation
------------

[](#installation)

```
composer require holoyan/eloquent-filter

```

Basic Usage
-----------

[](#basic-usage)

Let's say we want to return a list of users filtered by multiple parameters. For example this is our request url: `/users?email=jo&categories[]=3&categories[]=4&role=admin`

`$request->all()` will return:

```
[
   'email'       => 'jo',
   'categories'  => [3, 4],
   'role' => 'admin'
]
```

To filter by all those parameters we can simply write

```

 namespace App\Http\Controllers;

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

 class UserController extends Controller
 {
     public function index(Request $request)
     {
         return User::filter($request->all())->get();
     }
 }
```

In our `User` model we must import `Filterable` trait

```
namespace App\Models;

// import Filterable trait
use holoyan\EloquentFilter\Filterable;
use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable
{
    use Filterable;

    // other stuff here
}
```

then create class called `UserFilter` in `App\Http\Filters` folder

```
namespace App\Http\Filters;

use holoyan\EloquentFilter\Filter;
use holoyan\EloquentFilter\Rules\SimpleRule;

class UserFilter extends Filter
{

    public function rules()
    {
        return [
            'email' => SimpleRule::make()->startsWith(),
            'categories' => SimpleRule::make(),
            'role' => SimpleRule::make(),
        ];
    }
}
```

Query returns all users whose name starts with `jo`, belongs to category 3 or 4 and have `role` admin.

By default, package will look for filter class in `App\Http\Filters` folder with name `ModelFilter`, but if you want ypu can customize this behavior.

add `$filterClass` static property in model.

```
namespace App\Models;

use holoyan\EloquentFilter\Filterable;
use Illuminate\Foundation\Auth\User as Authenticatable;

// your custom filter class
use App\Filters\MyFilter;

class User extends Authenticatable
{
    use Filterable;

    public static $filterClass = MyCustomFilter::class;
    // other stuff here
}
```

Dynamic filter
--------------

[](#dynamic-filter)

Sometimes you may want to use a dynamic filter depending on conditions. In this case you can pass second argument to filter method which is the filter class:

```
$filter = $user->isAdmin() ? AdminFilter::class : BasicFilter::class;

User::filter($request->all(), $filter)->get();
```

Customize column
----------------

[](#customize-column)

You can also customize your column name

```
    public function rules()
    {
        return [
            'firstName' => SimpleRule::make()->setColumn('first_name'),
        ];
    }
```

Customize value
---------------

[](#customize-value)

```
    public function rules()
    {
        return [
            'firstName' => SimpleRule::make()->setvalue(function($value){
                return $value . 'test';
}           ),
        ];
    }
```

Available filters
-----------------

[](#available-filters)

- `SimpleRule::make() - by default, this will check for exact match`

```
    public function rules()
    {
        return [
            'name' => SimpleRule::make()
        ];
    }
```

if you want to use `like` comparison type you can use one of those methods:

```
        return [
            // where name="value"
            'name' => SimpleRule::make(),
            // where name like "value%"
            'name' => SimpleRule::make()->startsWith(),
            // where name like "%value"
            'name' => SimpleRule::make()->endsWith(),
            // where name like "%value%"
            'name' => SimpleRule::make()->contains()
        ];
```

- `RawRule::make()` - this allows you to specify callback function with your own logic

```
        return [
            'name' => RawRule::make()->setCallback(function($query, $column, $value){
                $query->where('name', '', $value);
            })
        ];
```

- `RelationRule::class` - for relation filter, check [bellow](#relation-filter) for more details

Ordering
--------

[](#ordering)

To order result use `OrderRule` rule

```
    // filter request
    $request = [
        'order' => 'desc'
    ];

    // filter class
    return [
        'name' => SimpleRule::make(),
        // other rules ......
        'order' => OrderRule::make()->setColumn('id'),
    ];
```

Relation filter
---------------

[](#relation-filter)

Suppose `User` has `Product` relation, and we want to return all users which have product which name starts with 'cook'

```
        return [
            'name' => SimpleRule::make(),
            'products' => RelationRule::make()->setRelation('products')->setRules([
                'name' => SimpleRule::make()->startsWith(),
            ]),
        ];
```

This allows you recursively pass any rules you want

Nested filter
-------------

[](#nested-filter)

To make nested filter we need to use `NestedRule::class`

```
        return [
            'b_date' => NestedRule::make()->setRules([
                'from' => SimpleRule::make()->setOperator('>='),
                'to' => SimpleRule::make()->setOperator('