borobudur-php / borobudur-cqrs

src/Collection.php

<?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\ReadModel\Storage\Finder\Pagination;
use Borobudur\Serialization\SerializableInterface;
use Closure;

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

    /**
     * @var Pagination
     */
    private $pagination;

    /**
     * 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 filter(Closure $p)
    {
        return new static(array_filter($this->elements, $p), $this->classMapper);
    }

    /**
     * {@inheritdoc}
     */
    public function map(Closure $p)
    {
        return new static(array_map($p, $this->elements), $this->classMapper);
    }

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

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

    /**
     * @param Pagination $pagination
     */
    public function setPagination(Pagination $pagination)
    {
        $this->pagination = $pagination;
    }

    /**
     * @return Pagination
     */
    public function getPagination()
    {
        return $this->pagination;
    }

    /**
     * {@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) {

The expression $fields of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                        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\Serialization\SerializableInterface', class_implements($classMapper))) {
                throw new InvalidArgumentException(sprintf(
                    'Class "%s" should implement \Borobudur\Serialization\SerializableInterface',
                    $classMapper
                ));
            }

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