Borobudur\Cqrs\ViewModel\ViewModel

Complexity

Total Complexity

51

Size/Duplication

Total Lines	373
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes	6
Bugs	2	Features	1

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	init()	0	9	4
B	build()	0	29	6
A	isCollection()	0	9	3
A	addParameter()	0	4	1
A	setForceSingle()	0	6	2
A	addFields()	0	4	1
A	addAppend()	0	4	1
A	addHidden()	0	4	1
A	buildViewModelArgs()	0	15	3
A	getRawData()	0	4	1
A	fields()	0	4	1
A	append()	0	4	1
A	hidden()	0	4	1
A	serialize()	0	18	4
A	normalize()	0	12	4
A	computeViewModelValue()	0	16	3
A	mergeFields()	0	6	1
A	setData()	0	15	2
B	buildData()	0	12	5
A	assertDataType()	0	10	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\ViewModel;

use Borobudur\Cqrs\Collection;
use Borobudur\Cqrs\Exception\InvalidArgumentException;
use Borobudur\Cqrs\ParameterBag;
use Borobudur\Cqrs\ReadModel\ReadModelInterface;
use ReflectionObject;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/20/15
 */
class ViewModel extends AbstractViewModel
{
    /**
     * @var Aggregate|null
     */
    protected $aggregate;

    /**
     * @var string
     */
    protected $prefixMethod = 'normalize';

    /**
     * @var bool
     */
    protected $allowForceSingle = true;

    /**
     * @var ParameterBag
     */
    protected $parameter;

    /**
     * @var array
     */
    private $fields = array();

    /**
     * @var array
     */
    private $append = array();

    /**
     * @var array
     */
    private $hidden = array();

    /**
     * @var mixed
     */
    private $data;

    /**
     * @var array|null
     */
    private $built;

    /**
     * @var bool
     */
    private $forceSingle = false;

    /**
     * Constructor.
     *
     * @param mixed $data
     * @param array $parameter
     */
    public function __construct($data, array $parameter = array())
    {
        if (empty($data)) {
            $this->built = array();
        } else {
            $this->parameter = new ParameterBag($parameter);
            $this->init($data);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function init($data)
    {
        $this->fields = $this->fields() ?: array();
        $this->append = $this->append() ?: array();
        $this->hidden = $this->hidden() ?: array();
        $this->setData($data);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function build()
    {
        if (null !== $this->built) {
            return $this->built;
        }

        $record = $this->data;

        if ($record instanceof ReadModelInterface) {
            $built = $this->serialize($record, $record->serialize());
        } elseif (is_array($record)) {
            $built = $this->serialize($record, $record);
        } else {
            $built = array_map(function ($readModel) use ($record) {
                if ($readModel instanceof ReadModelInterface) {
                    $readModel = $readModel->serialize();
                }

                return $this->serialize($record, $readModel);
            }, $record->toArray());
        }

        if ($this->forceSingle) {
            $built = $built[0];

        }

        return $this->built = $built;
    }

    /**
     * {@inheritdoc}
     */
    public function isCollection()
    {
        $build = $this->build();
        if (isset($build[0]) && is_array($build[0])) {
            return true;
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function addParameter(array $parameters)
    {
        $this->parameter->add($parameters);
    }

    /**
     * {@inheritdoc}
     */
    public function setForceSingle()
    {
        if ($this->allowForceSingle) {
            $this->forceSingle = true;
        }
    }

    /**
     * Add fields that should be viewed.
     *
     * @param array $fields
     */
    public function addFields(array $fields)
    {
        $this->fields = array_merge($this->fields, $fields);
    }

    /**
     * Add fields that should be appended.
     *
     * @param array $fields
     */
    public function addAppend(array $fields)
    {
        $this->append = array_merge($this->append, $fields);
    }

    /**
     * Add fields that should be hidden.
     *
     * @param array $fields
     */
    public function addHidden(array $fields)
    {
        $this->hidden = array_merge($this->fields, $fields);
    }

    /**
     * {@inheritdoc}
     */
    public function buildViewModelArgs($results, array $record, $field)
    {
        $args = array();
        if (array_key_exists($field, $record)) {
            $args[] = $record[$field];
        }

        $args[] = $record;

        if ($results instanceof Collection) {
            $args[] = $results;
        }

        return $args;
    }

    /**
     * Get view model raw data.
     *
     * @return mixed
     */
    public function getRawData()
    {
        return $this->data;
    }

    /**
     * {@inheritdoc}
     */
    protected function fields()
    {
        return array();
    }

    /**
     * {@inheritdoc}
     */
    protected function append()
    {
        return array();
    }

    /**
     * {@inheritdoc}
     */
    protected function hidden()
    {
        return array();
    }

    /**
     * Serialize record based on view model.
     *
     * @param mixed $results
     * @param array $record
     *
     * @return array
     */
    private function serialize($results, array $record)
    {
        $fields = (array) $this->fields();
        $fields = !empty($fields) ? $fields : array_keys($record);
        $fields = $this->mergeFields($fields, (array) $this->append());
        $hidden = (array) $this->hidden();

        $data = array();
        foreach ($fields as $field) {
            if (in_array($field, $hidden)) {
                continue;
            }

            $data[$field] = $this->computeViewModelValue($results, $record, $field);
        }

        return $data;
    }

    /**
     * Normalize array record.
     *
     * @param mixed $record
     *
     * @return array
     */
    private function normalize($record)
    {
        if (is_array($record)) {
            foreach ($record as $index => $value) {
                $record[$index] = $this->normalize($value);
            }
        } elseif ($record instanceof Collection) {
            return $record->toArray();
        }

        return $record;
    }

    /**
     * Compute view model value.
     *
     * @param mixed  $results
     * @param array  $record
     * @param string $field
     *
     * @return mixed|null
     */
    private function computeViewModelValue($results, array $record, $field)
    {
        $method = $this->prefixMethod . ucfirst($field);
        if (method_exists($this, $method)) {
            return call_user_func_array(
                array($this, $method),
                $this->buildViewModelArgs($results, $record, $field)
            );
        }

        if (isset($record[$field])) {
            return $record[$field];
        }

        return null;
    }

    /**
     * Merged key fields.
     *
     * @param array $recordFields
     * @param array $viewModelFields
     *
     * @return array
     */
    private function mergeFields(array $recordFields, array $viewModelFields)
    {
        $merged = array_merge(array_flip($recordFields), array_flip($viewModelFields));

        return array_keys($merged);
    }

    /**
     * Set data.
     *
     * @param mixed $data
     */
    private function setData($data)
    {
        $data = $this->buildData($this->normalize($data));
        $this->assertDataType($data);
        $this->data = $data;

        if ($this->data instanceof Collection) {
            $this->aggregate = new Aggregate(
                $this->data->toArray(),
                $this,
                new ReflectionObject($this),
                $this->prefixMethod
            );
        }
    }

    /**
     * Build data.
     *
     * @param mixed $data
     *
     * @return mixed
     */
    private function buildData($data)
    {
        if (!$data instanceof ReadModelInterface) {
            if ($data instanceof ViewModel) {
                $data = $data->isCollection() ? new Collection($data->build()) : $data->build();
            } elseif (!$data instanceof Collection) {
                $data = new Collection($data);
            }
        }

        return $data;
    }

    /**
     * Assert data type.
     *
     * @param mixed $data
     */
    private function assertDataType($data)
    {
        if (!$data instanceof ReadModelInterface && !$data instanceof Collection && !is_array($data)) {
            throw new InvalidArgumentException(sprintf(
                'Acceptable data type is \Borobudur\Cqrs\ReadModel\ReadModelInterface, ' .
                '\Borobudur\Cqrs\Collection, Borobudur\Cqrs\ViewModel\ViewModel or nested array, but got "%s".',
                gettype($data)
            ));
        }
    }
}