Spiral\ODM\Entities\DocumentSource

Complexity

Total Complexity

16

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	3
A	getClass()	0	4	1
A	create()	0	5	1
A	findByPK()	0	4	1
A	findOne()	0	4	1
A	find()	0	4	1
A	count()	0	4	1
A	getIterator()	0	4	1
A	withSelector()	0	7	1
A	setSelector()	0	4	1
A	getSelector()	0	9	2
A	iocContainer()	0	9	2

<?php
/**
 * Spiral, Core Components
 *
 * @author Wolfy-J
 */

namespace Spiral\ODM\Entities;

use Spiral\Core\Component;
use Spiral\Core\Traits\SaturateTrait;
use Spiral\ODM\CompositableInterface;
use Spiral\ODM\Document;
use Spiral\ODM\Exceptions\SourceException;
use Spiral\ODM\ODM;
use Spiral\ODM\ODMInterface;

/**
 * Source class associated to one or multiple (default implementation) ODM models. Source can be
 * used to write your own custom find method or change default selection.
 */
class DocumentSource extends Component implements \Countable, \IteratorAggregate
{
    use SaturateTrait;

    /**
     * Linked document model. ODM can automatically index and link user sources to models based on
     * value of this constant.
     *
     * Use this constant in custom source implementation in order to automatically link it to
     * appropriate model AND be able to create source as constructor or method injection without
     * ODM dependency.
     */
    const DOCUMENT = null;

    /**
     * @var DocumentSelector
     */
    private $selector;

    /**
     * Associated document class.
     *
     * @var string
     */
    private $class = null;

    /**
     * @invisible
     *
     * @var ODMInterface
     */
    protected $odm = null;

    /**
     * @param string       $class
     * @param ODMInterface $odm
     *
     * @throws SourceException
     */
    public function __construct(string $class = null, ODMInterface $odm = null)
    {
        if (empty($class)) {
            if (empty(static::DOCUMENT)) {
                throw new SourceException('Unable to create source without associated class');
            }

            $class = static::DOCUMENT;
        }

        $this->class = $class;
        $this->odm = $this->saturate($odm, ODMInterface::class);
    }

    /**
     * Associated class.
     *
     * @return string
     */
    public function getClass(): string
    {
        return $this->class;
    }

    /**
     * Create new DocumentEntity based on set of provided fields.
     *
     * @final Change static method of entity, not this one.
     *
     * @param array  $fields
     * @param string $class  Due ODM models can be inherited you can use this argument to specify
     *                       custom model class.
     *
     * @return CompositableInterface|Document
     */
    public function create($fields = [], string $class = null)
    {
        //Create model with filtered set of fields
        return $this->odm->make($class ?? $this->class, $fields, true);
    }

    /**
     * Find document by it's primary key.
     *
     * @see findOne()
     *
     * @param string|\MongoId $id Primary key value.
     *
     * @return CompositableInterface|Document|null
     */
    public function findByPK($id)
    {
        return $this->findOne(['_id' => ODM::mongoID($id)]);
    }

    /**
     * Select one document from mongo collection.
     *
     * @param array $query  Fields and conditions to query by.
     * @param array $sortBy Always specify sort by to ensure that results are stable.
     *
     * @return CompositableInterface|Document|null
     */
    public function findOne(array $query = [], array $sortBy = [])
    {
        return $this->getSelector()->sortBy($sortBy)->findOne($query);
    }

    /**
     * Get associated document selection with pre-configured query (if any).
     *
     * @param array $query
     *
     * @return DocumentSelector
     */
    public function find(array $query = []): DocumentSelector
    {
        return $this->getSelector()->where($query);
    }

    /**
     * @param array $query
     *
     * @return int
     */
    public function count(array $query = []): int
    {
        return $this->getSelector()->count($query);
    }

    /**
     * @return DocumentSelector
     */
    public function getIterator(): DocumentSelector
    {
        return $this->getSelector();
    }

    /**
     * Create source with new associated selector.
     *
     * @param DocumentSelector $selector
     *
     * @return DocumentSource
     */
    public function withSelector(DocumentSelector $selector): DocumentSource
    {
        $source = clone $this;
        $source->setSelector($selector);

        return $source;
    }

    /**
     * Set initial selector.
     *
     * @param DocumentSelector $selector
     */
    protected function setSelector(DocumentSelector $selector)
    {
        $this->selector = clone $selector;
    }

    /**
     * Get associated selector.
     *
     * @return DocumentSelector
     */
    protected function getSelector(): DocumentSelector
    {
        if (empty($this->selector)) {
            //Requesting selector on demand
            $this->selector = $this->odm->selector($this->class);
        }

        return clone $this->selector;
    }

    /**
     * {@inheritdoc}
     */
    protected function iocContainer()
    {
        if ($this->odm instanceof Component) {
            //Always work in ODM scope
            return $this->odm->iocContainer();
        }

        return parent::iocContainer();
    }
}