recca0120/repository

Repository for Laravel 5

v2.5.0 2021-04-27 06:30 UTC

README

StyleCI Build Status Total Downloads Latest Stable Version Latest Unstable Version License Monthly Downloads Daily Downloads Scrutinizer Code Quality Code Coverage

Install

To get the latest version of Laravel Exceptions, simply require the project using Composer:

composer require recca0120/repository

Instead, you may of course manually update your require block and run composer update if you so choose:

{
    "require": {
        "recca0120/repository": "~2.0.0"
    }
}

Methods

Recca0120\Repository\EloquentRepository

  • find($id, $columns = ['*']);
  • findMany($ids, $columns = ['*']);
  • findOrFail($id, $columns = ['*']);
  • findOrNew($id, $columns = ['*']);
  • firstOrNew(array $attributes, array $values = []);
  • firstOrCreate(array $attributes, array $values = []);
  • updateOrCreate(array $attributes, array $values = []);
  • firstOrFail($criteria = [], $columns = ['*']);
  • create($attributes);
  • forceCreate($attributes);
  • update($id, $attributes);
  • forceUpdate($id, $attributes);
  • delete($id);
  • forceDelete($id);
  • newInstance($attributes = [], $exists = false);
  • get($criteria = [], $columns = ['*']);
  • chunk($criteria, $count, callable $callback);
  • each($criteria, callable $callback, $count = 1000);
  • first($criteria = [], $columns = ['*']);
  • paginate($criteria = [], $perPage = null, $columns = ['*'], $pageName = 'page', $page = null);
  • simplePaginate($criteria = [], $perPage = null, $columns = ['*'], $pageName = 'page', $page = null);
  • count($criteria = [], $columns = '*');
  • min($criteria, $column);
  • max($criteria, $column);
  • sum($criteria, $column);
  • avg($criteria, $column);
  • average($criteria, $column);
  • matching($criteria);
  • getQuery($criteria = []);
  • getModel();
  • newQuery();

Recca0120\Repository\Criteria

  • static create()
  • static expr($value)
  • static raw($value)
  • select($columns = ['*'])
  • selectRaw($expression, array $bindings = [])
  • selectSub($query, $as)
  • addSelect($column)
  • distinct()
  • from($table)
  • join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false)
  • joinWhere($table, $first, $operator, $second, $type = 'inner')
  • leftJoin($table, $first, $operator = null, $second = null)
  • leftJoinWhere($table, $first, $operator, $second)
  • rightJoin($table, $first, $operator = null, $second = null)
  • rightJoinWhere($table, $first, $operator, $second)
  • crossJoin($table, $first = null, $operator = null, $second = null)
  • mergeWheres($wheres, $bindings)
  • tap($callback)
  • where($column, $operator = null, $value = null, $boolean = 'and')
  • orWhere($column, $operator = null, $value = null)
  • whereColumn($first, $operator = null, $second = null, $boolean = 'and')
  • orWhereColumn($first, $operator = null, $second = null)
  • whereRaw($sql, $bindings = [], $boolean = 'and')
  • orWhereRaw($sql, array $bindings = [])
  • whereIn($column, $values, $boolean = 'and', $not = false)
  • orWhereIn($column, $values)
  • whereNotIn($column, $values, $boolean = 'and')
  • orWhereNotIn($column, $values)
  • whereNull($column, $boolean = 'and', $not = false)
  • orWhereNull($column)
  • whereNotNull($column, $boolean = 'and')
  • whereBetween($column, array $values, $boolean = 'and', $not = false)
  • orWhereBetween($column, array $values)
  • whereNotBetween($column, array $values, $boolean = 'and')
  • orWhereNotBetween($column, array $values)
  • orWhereNotNull($column)
  • whereDate($column, $operator, $value = null, $boolean = 'and')
  • orWhereDate($column, $operator, $value)
  • whereTime($column, $operator, $value, $boolean = 'and')
  • orWhereTime($column, $operator, $value)
  • whereDay($column, $operator, $value = null, $boolean = 'and')
  • whereMonth($column, $operator, $value = null, $boolean = 'and')
  • whereYear($column, $operator, $value = null, $boolean = 'and')
  • whereNested(Closure $callback, $boolean = 'and')
  • addNestedWhereQuery($query, $boolean = 'and')
  • whereExists(Closure $callback, $boolean = 'and', $not = false)
  • orWhereExists(Closure $callback, $not = false)
  • whereNotExists(Closure $callback, $boolean = 'and')
  • orWhereNotExists(Closure $callback)
  • addWhereExistsQuery(Builder $query, $boolean = 'and', $not = false)
  • dynamicWhere($method, $parameters)
  • groupBy()
  • having($column, $operator = null, $value = null, $boolean = 'and')
  • orHaving($column, $operator = null, $value = null)
  • havingRaw($sql, array $bindings = [], $boolean = 'and')
  • orHavingRaw($sql, array $bindings = [])
  • orderBy($column, $direction = 'asc')
  • orderByDesc($column)
  • latest($column = 'created_at')
  • oldest($column = 'created_at')
  • inRandomOrder($seed = '')
  • orderByRaw($sql, $bindings = [])
  • skip($value)
  • offset($value)
  • take($value)
  • limit($value)
  • forPage($page, $perPage = 15)
  • forPageAfterId($perPage = 15, $lastId = 0, $column = 'id')
  • union($query, $all = false)
  • unionAll($query)
  • lock($value = true)
  • lockForUpdate()
  • sharedLock()
  • when($value, $callback, $default = null)
  • unless($value, $callback, $default = null)
  • whereKey($id)
  • whereKeyNot($id)
  • with($relations)
  • without($relations)
  • setQuery($query)
  • setModel(Model $model)
  • has($relation, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null)
  • orHas($relation, $operator = '>=', $count = 1)
  • doesntHave($relation, $boolean = 'and', Closure $callback = null)
  • whereHas($relation, Closure $callback = null, $operator = '>=', $count = 1)
  • orWhereHas($relation, Closure $callback = null, $operator = '>=', $count = 1)
  • whereDoesntHave($relation, Closure $callback = null)
  • withCount($relations)
  • mergeConstraintsFrom(Builder $from)
  • withTrashed()
  • withoutTrashed()
  • onlyTrashed()

Usage

Eloquent

Create a Model

Create your model normally, but it is important to define the attributes that can be filled from the input form data.

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = [
        'title',
        'author',
     ];
}

Create a Contract

namespace App\Repositories\Contracts;

interface PostRepository
{

}

Create a Repository

namespace App\Repositories;

use App\Repositories\Contracts\PostRepository as PostRepositoryContract;
use App\Post;
use Recca0120\Repository\EloquentRepository;

class PostRepository extends EloquentRepository implements PostRepositoryContract
{
    public function __construct(Post $model)
    {
        $this->model = $model;
    }
}

Bind

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Repositories\Contracts\PostRepository as PostRepositoryContract;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->singleton(PostRepositoryContract::class, PostRepository::class);
    }
}

Controller

namespace App\Http\Controllers;

use App\Repositories\Contracts\PostRepository;

class PostsController extends Controller
{
    protected $repository;

    public function __construct(PostRepository $repository)
    {
        $this->repository = $repository;
    }
}

Methods

Find all results in Repository

$posts = $this->repository->get();

Find all results in Repository with pagination

$posts = $this->repository->paginate();

Count results in Repository

$posts = $this->repository->count();

Create new entry in Repository

$post = $this->repository->create(request()->all());

Update entry in Repository

$post = $this->repository->update($id, request()->all());

Delete entry in Repository

$this->repository->delete($id);

New instance

$post = $this->repository->newInstance([
    'author' => 'author'
]);

Return Model With Conditions

$model = $this->repository->matching(Criteria::create()->where('title', '=', 'title'));

Find result by id

$post = $this->repository->find($id);

Find by conditions

Using the Criteria

Criteria is support all of Eloquent functions

Single Criteria
use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->select('*')
    ->where('author', '=', 'author')
    ->orWhere('title', '=', 'title')
    ->orderBy('author', 'asc');

$this->repository->get($criteria);
$this->repository->paginate($criteria);

Multiple Criteria

use Recca0120\Repository\Criteria;

$criteria = [];

$criteria[] = Criteria::create()
    ->orderBy('author', 'asc');

$criteria[] = Criteria::create()
    ->where('author', '=', 'author')
    ->orWhere('title', '=', 'title');

$this->repository->get($criteria);
// $this->repository->paginate($criteria);
With
use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->with('author', function($criteria) {
        $criteria->where('author', 'author');
    });

$this->repository->get($criteria);
// $this->repository->paginate($criteria);

Join

use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->join('author', function ($criteria) {
        $criteria->on('posts.author_id', '=', 'author.id');
    });

$this->repository->get($criteria);
// $this->repository->paginate($criteria);

Expression

use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->where('created_at', '<=', Criteria::expr('NOW()'));

$this->repository->get($criteria);
// $this->repository->paginate($criteria);

Custom Criteria

use Recca0120\Repository\Criteria;

class CustomCriteria extends Criteria
{
    public function __construct($id)
    {
        $this->where('id', '=', $id);
    }
}

$this->repository->get((new CustomCriteria(1))->where('autor', 'autor'));

ToDo

  • Cache