NilPortugues\Foundation\Infrastructure\Model\Repository\FileSystem\FileSystemRepository

Complexity

Total Complexity

17

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	3
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	find()	0	4	1
A	count()	0	10	2
A	exists()	0	4	1
A	addAll()	0	7	2
A	add()	0	4	1
A	removeAll()	0	15	3
A	findBy()	0	14	3
A	remove()	0	4	1
A	findAll()	0	17	2

<?php

/**
 * Author: Nil Portugués Calderó <contact@nilportugues.com>
 * Date: 6/02/16
 * Time: 13:05.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace NilPortugues\Foundation\Infrastructure\Model\Repository\FileSystem;

use NilPortugues\Assert\Assert;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Fields;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Filter;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Identity;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Page;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Pageable;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\PageRepository;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\ReadRepository;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\Sort;
use NilPortugues\Foundation\Domain\Model\Repository\Contracts\WriteRepository;
use NilPortugues\Foundation\Domain\Model\Repository\Page as ResultPage;
use NilPortugues\Foundation\Infrastructure\Model\Repository\FileSystem\Contracts\FileSystem;
use NilPortugues\Foundation\Infrastructure\Model\Repository\InMemory\Filter as InMemoryFilter;
use NilPortugues\Foundation\Infrastructure\Model\Repository\InMemory\Sorter as InMemorySorter;

/**
 * Class FileSystemRepository.
 */
class FileSystemRepository implements ReadRepository, WriteRepository, PageRepository
{
    /**
     * @var FileSystem
     */
    protected $fileSystem;

    /**
     * FileSystemRepository constructor.
     *
     * @param FileSystem $fileSystem
     */
    public function __construct(FileSystem $fileSystem)
    {
        $this->fileSystem = $fileSystem;
    }

    /**
     * Retrieves an entity by its id.
     *
     * @param Identity    $id
     * @param Fields|null $fields
     *
     * @return mixed
     */
    public function find(Identity $id, Fields $fields = null)
    {
        return $this->fileSystem->read($id->id());
    }

    /**
     * Returns the total amount of elements in the repository given the restrictions provided by the Filter object.
     *
     * @param Filter|null $filter
     *
     * @return int
     */
    public function count(Filter $filter = null)
    {
        $allFiles = $this->fileSystem->files();

        if ($filter) {
            $allFiles = InMemoryFilter::filter($allFiles, $filter);
        }

        return count($allFiles);
    }

    /**
     * Returns whether an entity with the given id exists.
     *
     * @param $id
     *
     * @return bool
     */
    public function exists(Identity $id)
    {
        return $this->fileSystem->exists($id);
    }

    /**
     * Adds a collections of entities to the storage.
     *
     * @param array $values
     *
     * @return mixed
     */
    public function addAll(array $values)
    {
        foreach ($values as $value) {
            Assert::isInstanceOf($value, Identity::class);
            $this->add($value);
        }
    }

    /**
     * Adds a new entity to the storage.
     *
     * @param Identity $value
     *
     * @return mixed
     */
    public function add(Identity $value)
    {
        $this->fileSystem->write($value->id(), $value);
    }

    /**
     * Removes all elements in the repository given the restrictions provided by the Filter object.
     * If $filter is null, all the repository data will be deleted.
     *
     * @param Filter $filter
     *
     * @return bool
     */
    public function removeAll(Filter $filter = null)
    {
        if (null === $filter) {
            $this->fileSystem->deleteAll();

            return true;
        }

        $elements = (array) $this->findBy($filter);
        foreach ($elements as $element) {
            $this->remove($element);
        }

        return true;
    }

    /**
     * Returns all instances of the type.
     *
     * @param Filter|null $filter
     * @param Sort|null   $sort
     * @param Fields|null $fields
     *
     * @return array
     */
    public function findBy(Filter $filter = null, Sort $sort = null, Fields $fields = null)
    {
        $allFiles = $this->fileSystem->files();

        if ($filter) {
            $allFiles = InMemoryFilter::filter($allFiles, $filter);
        }

        if ($sort) {
            $allFiles = InMemorySorter::sort($allFiles, $sort);
        }

        return $allFiles;
    }

    /**
     * Removes the entity with the given id.
     *
     * @param $id
     */
    public function remove(Identity $id)
    {
        $this->fileSystem->delete($id);
    }

    /**
     * Returns a Page of entities meeting the paging restriction provided in the Pageable object.
     *
     * @param Pageable $pageable
     *
     * @return Page
     */
    public function findAll(Pageable $pageable = null)
    {
        if (null === $pageable) {
            $files = $this->findBy();

            return new ResultPage($files, count($files), 1, 1);
        }

        $results = $this->findBy($pageable->filters(), $pageable->sortings());

        return new ResultPage(
            array_slice($results, $pageable->offset() - $pageable->pageSize(), $pageable->pageSize()),
            count($results),
            $pageable->pageNumber(),
            ceil(count($results) / $pageable->pageSize())
        );
    }
}