App\Domain\Models\Wiki\AbstractStrictWikiTemplate

Complexity

Total Complexity

40

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	hasParamValue()	0	11	3
A	hydrate()	0	9	3
B	isValidForEdit()	0	20	7
A	hydrateTemplateParameter()	0	4	2
A	getParamsAndAlias()	0	3	1
A	getParam()	0	10	2
A	isValidParamName()	0	14	4
A	getAliasParam()	0	7	2
A	__construct()	0	9	3
A	paramsByRenderOrder()	0	12	3
A	keepMinimumOrNotEmpty()	0	11	4
A	unsetParam()	0	9	2
A	setParam()	0	15	4

<?php
/**
 * This file is part of dispositif/wikibot application (@github)
 * 2019/2020 © Philippe M. <dispositif@gmail.com>
 * For the full copyright and MIT license information, please view the license file.
 */

declare(strict_types=1);

namespace App\Domain\Models\Wiki;

use App\Domain\Utils\ArrayProcessTrait;
use Exception;
use Throwable;

abstract class AbstractStrictWikiTemplate extends AbstractParametersObject implements WikiTemplateInterface
{
    use ArrayProcessTrait, InfoTrait;
    /**
     * Name of the wiki-template
     */
    const WIKITEMPLATE_NAME = 'NO NAME';

    /**
     * Error in wiki parsing without those required params.
     */
    const REQUIRED_PARAMETERS = [];
    /**
     * The minimum parameters for pretty wiki-template.
     */
    const MINIMUM_PARAMETERS = [];

    /* commented to allow inherit from Interface in OuvrageTemplate
       const PARAM_ALIAS = []; */

    const COMMENT_STRIPPED = '<!-- Paramètre obligatoire -->';

    public $log = [];

    /**
     * AbstractWikiTemplate constructor.
     *
     * @throws Exception
     */
    public function __construct()
    {
        if (empty(static::MINIMUM_PARAMETERS)) {

The condition empty(static::MINIMUM_PARAMETERS) is always true.

            throw new Exception(sprintf('DEFAULT_PARAMETERS not configured in "%s"', get_called_class()));
        }
        $this->parametersValues = static::MINIMUM_PARAMETERS;

        if (empty($this->parametersByOrder)) {
            $this->parametersByOrder = static::MINIMUM_PARAMETERS;
        }
    }

    public function getParamsAndAlias(): array
    {
        return array_merge($this->parametersByOrder, array_keys(static::PARAM_ALIAS));

The constant App\Domain\Models\Wiki\AbstractStrictWikiTemplate::PARAM_ALIAS was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    /**
     * @param array $data
     *
     * @return AbstractStrictWikiTemplate
     * @throws Exception
     */
    public function hydrate(array $data): AbstractStrictWikiTemplate
    {
        foreach ($data as $name => $value) {
            if (is_string($value)) {
                $this->hydrateTemplateParameter($name, $value);
            }
        }

        return $this;
    }

    /**
     * @param        $name
     * @param string $value
     *
     * @throws Exception
     */
    protected function hydrateTemplateParameter($name, string $value): void
    {
        if ($this->isValidParamName($name)) {
            $this->setParam($name, $value);
        }
    }

    /**
     * Delete key if empty value and the key not required.
     *
     * @param array $params
     *
     * @return array
     */
    protected function keepMinimumOrNotEmpty(array $params): array
    {
        $render = [];
        foreach ($params as $name => $value) {
            if (empty($value) && !isset(static::MINIMUM_PARAMETERS[$name])) {
                continue;
            }
            $render[$name] = $params[$name];
        }

        return $render;
    }

    protected function paramsByRenderOrder(): array
    {
        $renderParams = [];

        // default order
        foreach ($this->parametersByOrder as $order => $paramName) {
            if (isset($this->parametersValues[$paramName])) {
                $renderParams[$paramName] = $this->parametersValues[$paramName];
            }
        }

        return $renderParams;
    }

    /**
     * @param string $name
     *
     * @return string|null
     * @throws Exception
     */
    public function getParam(string $name): ?string
    {
        if (!$this->isValidParamName($name)) {
            return null;
        }
        $name = $this->getAliasParam($name);
        // keyNum parameter ?
        //        if (!in_array($name, ['1', '2', '3', '4'])) {

        return ($this->parametersValues[$name]) ?? null;
    }

    /**
     * Todo replacement for old validOrExceptionOnParamName()
     *
     * @param $name
     *
     * @return bool
     */
    protected function isValidParamName($name): bool
    {
        if (is_int($name)) {
            $name = (string)$name;
        }

        // that parameter exists in template ?
        if (in_array($name, $this->parametersByOrder)
            || array_key_exists($name, static::PARAM_ALIAS)

The constant App\Domain\Models\Wiki\AbstractStrictWikiTemplate::PARAM_ALIAS was not found. Maybe you did not declare it correctly or list all dependencies?

        ) {
            return true;
        }

        return false;
    }

    /**
     * @param string $name
     *
     * @return $this
     * @throws Exception
     */
    public function unsetParam(string $name)
    {
        if (!$this->isValidParamName($name)) {
            throw new Exception(sprintf('no parameter "%s" in template "%s"', $name, get_called_class()));
        }
        $name = $this->getAliasParam($name);
        unset($this->parametersValues[$name]);

        return $this;
    }

    /**
     * TODO ? check if method set{ParamName} exists ?
     *
     * @param string $name
     * @param string $value
     *
     * @return AbstractParametersObject
     * @throws Exception
     */
    public function setParam(string $name, string $value): AbstractParametersObject
    {
        if (!$this->isValidParamName($name)) {
            $this->log[] = sprintf('no parameter "%s" in AbstractParametersObject "%s"', $name, get_called_class());

            return $this;
        }

        $name = $this->getAliasParam($name);
        $value = trim($value);
        if (!empty($value) || $this->parametersValues[$name]) {
            $this->parametersValues[$name] = $value;
        }

        return $this;
    }

    /**
     * todo peu utile en public
     *
     * @param string $name
     *
     * @return string
     */
    public function getAliasParam(string $name): string
    {
        if (array_key_exists($name, static::PARAM_ALIAS)) {

The constant App\Domain\Models\Wiki\AbstractStrictWikiTemplate::PARAM_ALIAS was not found. Maybe you did not declare it correctly or list all dependencies?

            $name = static::PARAM_ALIAS[$name];
        }

        return $name;
    }

    /**
     * For a parameter, check is the value exists (not empty).
     *
     * @param string $name
     *
     * @return bool
     * @throws Exception
     */
    public function hasParamValue(string $name): bool
    {
        try {
            if (!empty(trim($this->getParam($name)))) {
                return true;
            }
        } catch (Throwable $e) {
            unset($e);
        }

        return false;
    }

    /**
     * Verify the required template parameters for an edit by the bot.
     *
     * @return bool
     * @throws Exception
     * @throws Exception
     * @throws Exception
     * @throws Exception
     */
    public function isValidForEdit(): bool
    {
        $validParams = array_keys(static::MINIMUM_PARAMETERS);
        if (!empty(static::REQUIRED_PARAMETERS)) {
            $validParams = static::REQUIRED_PARAMETERS;
        }

        foreach ($validParams as $param) {
            if (in_array($param, ['date', 'année'])
                && ($this->hasParamValue('date') || $this->hasParamValue('année'))
            ) {
                // équivalence date-année
                continue;
            }
            if (!$this->hasParamValue($param)) {
                return false;
            }
        }

        return true;
    }

    public abstract function serialize(?bool $cleanOrder = false): string;

}