TxTextControl\ReportingCloud\BuildTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	154
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	buildDocumentSettingsArray()	0	21	5
A	buildPropertyMapArray()	0	16	4
B	buildMergeSettingsArray()	0	28	7
A	buildDocumentsArray()	0	26	5
A	buildFindAndReplaceDataArray()	0	12	2

<?php
declare(strict_types=1);

/**
 * ReportingCloud PHP Wrapper
 *
 * PHP wrapper for ReportingCloud Web API. Authored and supported by Text Control GmbH.
 *
 * @link      https://www.reporting.cloud to learn more about ReportingCloud
 * @link      https://github.com/TextControl/txtextcontrol-reportingcloud-php for the canonical source repository
 * @license   https://raw.githubusercontent.com/TextControl/txtextcontrol-reportingcloud-php/master/LICENSE.md
 * @copyright © 2019 Text Control GmbH
 */

namespace TxTextControl\ReportingCloud;

use TxTextControl\ReportingCloud\Assert\Assert;
use TxTextControl\ReportingCloud\Exception\InvalidArgumentException;
use TxTextControl\ReportingCloud\Filter\Filter;
use TxTextControl\ReportingCloud\PropertyMap\AbstractPropertyMap as PropertyMap;
use TxTextControl\ReportingCloud\PropertyMap\DocumentSettings as DocumentSettingsPropertyMap;
use TxTextControl\ReportingCloud\PropertyMap\MergeSettings as MergeSettingsPropertyMap;
use TxTextControl\ReportingCloud\Stdlib\StringUtils;

/**
 * Trait BuildTrait
 *
 * @package TxTextControl\ReportingCloud
 * @author  Jonathan Maron (@JonathanMaron)
 */
trait BuildTrait
{
    // <editor-fold desc="Methods">

    /**
     * Using the passed propertyMap, recursively build array
     *
     * @param array       $array       Array
     * @param PropertyMap $propertyMap PropertyMap
     *
     * @return array
     */
    protected function buildPropertyMapArray(array $array, PropertyMap $propertyMap): array
    {
        $ret = [];

        foreach ($array as $key => $value) {
            $map = $propertyMap->getMap();
            if (isset($map[$key])) {
                $key = $map[$key];
            }
            if (is_array($value)) {
                $value = $this->buildPropertyMapArray($value, $propertyMap);
            }
            $ret[$key] = $value;
        }

        return $ret;
    }

    /**
     * Using passed documentsData array, build array for backend
     *
     * @param array $array
     *
     * @return array
     * @throws InvalidArgumentException
     */
    protected function buildDocumentsArray(array $array): array
    {
        $ret = [];

        foreach ($array as $inner) {
            Assert::isArray($inner);
            $document = [];
            foreach ($inner as $key => $value) {
                switch ($key) {
                    case 'filename':
                        Assert::filenameExists($value);
                        Assert::assertDocumentExtension($value);
                        $data                 = (string) file_get_contents($value);
                        $data                 = base64_encode($data);
                        $document['document'] = $data;
                        break;
                    case 'divider':
                        Assert::assertDocumentDivider($value);
                        $document['documentDivider'] = $value;
                        break;
                }
            }
            $ret[] = $document;
        }

        return $ret;
    }

    /**
     * Using passed documentsSettings array, build array for backend
     *
     * @param array $array
     *
     * @return array
     * @throws InvalidArgumentException
     */
    protected function buildDocumentSettingsArray(array $array): array
    {
        $ret = [];

        $propertyMap = new DocumentSettingsPropertyMap();

        $map = $propertyMap->getMap();
        if (is_array($map)) {
            foreach ($map as $property => $key) {
                if (isset($array[$key])) {
                    $value = $array[$key];
                    if (StringUtils::endsWith($key, '_date')) {
                        Assert::assertTimestamp($value);
                        $value = Filter::filterTimestampToDateTime($value);
                    }
                    $ret[$property] = $value;
                }
            }
        }

        return $ret;
    }

    /**
     * Using passed mergeSettings array, build array for backend
     *
     * @param array $array MergeSettings array
     *
     * @return array
     * @throws InvalidArgumentException
     */
    protected function buildMergeSettingsArray(array $array): array
    {
        $ret = [];

        $propertyMap = new MergeSettingsPropertyMap();

        $map = $propertyMap->getMap();
        if (is_array($map)) {
            foreach ($map as $property => $key) {
                if (!isset($array[$key])) {
                    continue;
                }
                $value = $array[$key];
                if ('culture' === $key) {
                    Assert::assertCulture($value);
                }
                if (StringUtils::startsWith($key, 'remove_')) {
                    Assert::boolean($value);
                }
                if (StringUtils::endsWith($key, '_date')) {
                    Assert::assertTimestamp($value);
                    $value = Filter::filterTimestampToDateTime($value);
                }
                $ret[$property] = $value;
            }
        }

        return $ret;
    }

    /**
     * Using passed findAndReplaceData associative array (key-value), build array for backend (list of string arrays)
     *
     * @param array $array
     *
     * @return array
     */
    protected function buildFindAndReplaceDataArray(array $array): array
    {
        $ret = [];

        foreach ($array as $key => $value) {
            $ret[] = [
                $key,
                $value,
            ];
        }

        return $ret;
    }

    // </editor-fold>
}