CCT\Component\ODMElasticsearch\Transformer\Visitor\ReverseElasticsearchVisitor

Complexity

Total Complexity

20

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Test Coverage

Coverage

61.4%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	visitTime()	0	9	1
A	visitString()	0	3	1
A	visitDate()	0	7	2
A	visitArray()	0	13	3
A	prepare()	0	3	1
A	visitDouble()	0	3	1
A	visitNull()	0	3	1
A	visitObject()	0	3	1
A	normalizeDateFormat()	0	6	1
A	visitInteger()	0	3	1
A	visitBoolean()	0	3	1
A	convertToDataTime()	0	25	4
A	visitDateTime()	0	7	2

<?php

declare(strict_types=1);

namespace CCT\Component\ODMElasticsearch\Transformer\Visitor;

use CCT\Component\ODMElasticsearch\Transformer\Exception\TransformationFailedException;
use DateTime;

class ReverseElasticsearchVisitor extends AbstractReverseVisitor
{
    /**
     * Allows visitors to convert the input data to a different representation
     * before the actual formatting process starts.
     *
     * @param mixed $data
     *
     * @return mixed
     */
    public function prepare($data)
    {
        return $data;
    }

    /**
     * @param mixed $data
     * @param array $config
     *
     * @return mixed|null
     */
    public function visitNull($data, array $config)
    {
        return null;
    }

    /**
     * @param mixed $data
     * @param array $config
     *
     * @return mixed|string
     */
    public function visitString($data, array $config)
    {
        return (string)$data;
    }

    /**
     * @param mixed $data
     * @param array $config
     *
     * @return bool|mixed
     */
    public function visitBoolean($data, array $config)
    {
        return (bool)$data;
    }

    public function visitInteger($data, array $config)
    {
        return (int)$data;
    }

    public function visitDouble($data, array $config)
    {
        return (float)$data;
    }

    public function visitDate($data, array $config)
    {
        if (null === $data) {
            return null;
        }

        return $this->convertToDataTime($data);
    }

    /**
     * @param mixed $data
     * @param array $config
     *
     * @return mixed
     */
    public function visitDateTime($data, array $config)
    {
        if (null === $data) {
            return null;
        }

        return $this->convertToDataTime($data);
    }

    /**
     * @param mixed $data
     * @param array $config
     *
     * @return mixed
     */
    public function visitTime($data, array $config)
    {
        $inSeconds = (int)$data;

        $hours = floor($inSeconds / 3600);
        $minutes = floor($inSeconds / 60 % 60);
        $seconds = floor($inSeconds % 60);

        return sprintf('%02d:%02d:%02d', $hours, $minutes, $seconds);
    }

    /**
     * @param array $data
     * @param array $config
     *
     * @return mixed
     */
    public function visitArray(array $data, array $config)
    {
        $visitedArray = [];
        foreach ($data as $index => $item) {
            //Navigate over items again
            $itemConfig = null;
            if (isset($config['class'])) {
                $itemConfig = ['type' => 'object', 'params' => [], 'class' => $config['class']];
            }
            $visitedArray[$index] = $this->dataNavigator->navigate($item, $this, $itemConfig);
        }

        return $visitedArray;
    }

    public function visitObject($data, array $config)
    {
        return $this->navigateObjectHydrate($data, $config);
    }

    /**
     * @param string|integer $date
     *
     * @return \DateTimeInterface
     */
    private function convertToDataTime($date): ?\DateTimeInterface
    {
        try {
            if (is_int($date)) {
                $normalizedDate = $this->normalizeDateFormat((string)$date);
                $convertedDate = DateTime::createFromFormat(
                    'U.u',
                    $normalizedDate
                );

                if (false === $convertedDate) {
                    throw new TransformationFailedException(
                        sprintf('Date "%s" could not be converted to a DateTime object', (string)$date)
                    );
                }

                return $convertedDate;
            }

            return new DateTime($date);
        } catch (\Exception $exception) {
            throw new TransformationFailedException(
                sprintf('Date "%s" could not be converted to a DateTime object', (string)$date),
                0,
                $exception
            );
        }
    }

    /**
     * @param string $data
     *
     * @return string
     */
    protected function normalizeDateFormat(string $data): string
    {
        return sprintf(
            '%s.%s',
            substr($data, 0, 10),
            round((int) substr($data, -3, 3))
        );
    }
}