Borobudur\Cqrs\Collection

Complexity

Total Complexity

25

Size/Duplication

Total Lines	137
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes	4
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	findById()	0	8	1
A	set()	0	9	3
C	getFieldValues()	0	43	14
A	toArray()	0	12	2
A	assertValidClassMapper()	0	16	4

<?php
/*
 * This file is part of the Borobudur-Cqrs package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Cqrs;

use Borobudur\Collection\Collection as BaseCollection;
use Borobudur\Collection\Criteria;
use Borobudur\Cqrs\Exception\InvalidArgumentException;
use Borobudur\Cqrs\ReadModel\ReadModelInterface;
use Borobudur\Cqrs\Serializer\SerializableInterface;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/20/15
 */
class Collection extends BaseCollection
{
    /**
     * @var string|null
     */
    private $classMapper;

    /**
     * Constructor.
     *
     * @param array       $elements
     * @param string|null $classMapper
     */
    public function __construct(array $elements = array(), $classMapper = null)
    {
        $this->assertValidClassMapper($classMapper);
        $this->classMapper = $classMapper;

        parent::__construct($elements);
    }

    /**
     * Find collection by id.
     *
     * @param mixed $id
     *
     * @return ReadModelInterface
     */
    public function findById($id)
    {
        $collection = $this->matching(Criteria::create()->where(
            Criteria::expr()->equal('id', $id)
        ));

        return $collection->first();
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value)
    {
        if (null !== $this->classMapper && false === is_object($value)) {
            $class = $this->classMapper;
            $value = $class::{'deserialize'}(new ParameterBag($value));
        }

        parent::set($key, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function getFieldValues($field = null)
    {
        $fields = func_get_args();
        $elements = array();
        if ($fields || (isset($this->elements[0]) && is_array($this->elements[0]))) {
            $this->each(function ($element) use (&$elements, $fields) {
                if (is_object($element)) {
                    if ($fields) {
                        foreach ($fields as $field) {
                            $methodGet = 'get' . ucfirst($field);
                            $methodIs = 'is' . ucfirst($field);

                            if (method_exists($element, $methodGet)) {
                                $elements[] = $element->{$methodGet}();
                            } elseif (method_exists($element, $methodIs)) {
                                $elements[] = $element->{$methodIs}();
                            } elseif (property_exists($element, $field)) {
                                $elements[] = $element->{$field};
                            }
                        }
                    }

                    return;
                }

                if (is_array($element)) {
                    if ($fields) {
                        foreach ($fields as $field) {
                            if (array_key_exists($field, $element)) {
                                $elements[] = $element[$field];
                            }
                        }
                    } else {
                        $elements = array_merge($elements, array_values($element));
                    }
                }
            });

            return $elements;
        }

        return array();
    }

    /**
     * {@inheritdoc}
     */
    public function toArray($resortIndex = false)
    {
        $elements = parent::toArray($resortIndex);

        if (null !== $this->classMapper) {
            return array_map(function (SerializableInterface $element) {
                return $element->serialize();
            }, (array) $elements);
        }

        return $elements;
    }

    /**
     * Assert that class mapper should be exists and can be deserialize.
     *
     * @param string $classMapper
     *
     * @throws InvalidArgumentException
     */
    private function assertValidClassMapper($classMapper)
    {
        if (null !== $classMapper) {
            $classMapper = '\\' . ltrim($classMapper, '\\');
            if (!class_exists($classMapper)) {
                throw new InvalidArgumentException(sprintf('Class "%s" is undefined.', $classMapper));
            }

            if (!in_array('Borobudur\Cqrs\Serializer\SerializableInterface', class_implements($classMapper))) {
                throw new InvalidArgumentException(sprintf(
                    'Class "%s" should implement \Borobudur\Cqrs\Serializer\SerializableInterface',
                    $classMapper
                ));
            }
        }
    }
}