AmmitPhp\Ammit\UI\Resolver\AbstractPragmaticCommandResolver

Complexity

Total Complexity

6

Size/Duplication

Total Lines	83
Duplicated Lines	100 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	27	27	5
	resolve()	1	1	?
A	resolveRequestAsArray()	10	10	1
	validateThenMapAttributes()	1	1	?

<?php
declare(strict_types = 1);

namespace AmmitPhp\Ammit\UI\Resolver;

use AmmitPhp\Ammit\UI\Resolver\Validator\PragmaticRawValueValidator;
use AmmitPhp\Ammit\UI\Resolver\Validator\PragmaticRequestAttributeValueValidator;
use AmmitPhp\Ammit\UI\Resolver\Exception\CommandMappingException;
use AmmitPhp\Ammit\UI\Resolver\Exception\UIValidationCollectionException;
use AmmitPhp\Ammit\UI\Resolver\Validator\PragmaticRequestQueryStringValueValidator;
use Psr\Http\Message\ServerRequestInterface;

/**
 * Helper easing Command Resolver (mapping + UI Validation) implementation
 * @internal Contains Domain Validation assertions (but class won't be removed in next version)
 *   Prefer using AbstractPureCommandResolver
 *   Domain Validation should be done in Domain
 *   Should be used for prototyping project knowing you are accumulating technical debt
 */
abstract class AbstractPragmaticCommandResolver

This class seems to be duplicated in your project.

{
    /** @var UIValidationEngine */
    protected $validationEngine;

    /** @var PragmaticRawValueValidator */
    protected $rawValueValidator;

    /** @var PragmaticRequestAttributeValueValidator */
    protected $attributeValueValidator;

    /** @var PragmaticRequestQueryStringValueValidator */
    protected $queryStringValueValidator;

    public function __construct(UIValidationEngine $validationEngine = null, PragmaticRawValueValidator $rawValueValidator = null, PragmaticRequestAttributeValueValidator $attributeValueValidator = null, PragmaticRequestQueryStringValueValidator $queryStringValueValidator = null)
    {
        if (null === $validationEngine) {
            $validationEngine = UIValidationEngine::initialize();
        }

        if (null === $rawValueValidator) {
            $rawValueValidator = new PragmaticRawValueValidator($validationEngine);
        }

        if (null === $attributeValueValidator) {
            $attributeValueValidator = new PragmaticRequestAttributeValueValidator(
                $rawValueValidator
            );
        }

        if (null === $queryStringValueValidator) {
            $queryStringValueValidator = new PragmaticRequestQueryStringValueValidator(
                $rawValueValidator
            );
        }

        $this->validationEngine = $validationEngine;
        $this->rawValueValidator = $rawValueValidator;
        $this->attributeValueValidator = $attributeValueValidator;
        $this->queryStringValueValidator = $queryStringValueValidator;
    }

    /**
     * @api
     * Create a Command from a Request
     * Perform the UI Validation (simple validation)
     * Complex Validation will be done in the Domain
     * @param ServerRequestInterface $request PSR7 Request
     *
     * @return object Immutable Command (DTO)
     * @throws UIValidationCollectionException If any Validation fail
     */
    abstract public function resolve(ServerRequestInterface $request);

    /**
     * @api
     * Map a Command attributes from a Request into an array
     * Perform the UI Validation (simple validation)
     *
     * @return mixed[] Attributes used to create the Command
     * @throws CommandMappingException If any mapping validation failed
     * @throws UIValidationCollectionException If any UI validation failed
     */
    protected function resolveRequestAsArray(ServerRequestInterface $request): array
    {
        $values = $this->validateThenMapAttributes(
            $request
        );

        $this->validationEngine->guardAgainstAnyUIValidationException();

        return $values;
    }

    /**
     * @api
     * Resolve implementation
     * @param ServerRequestInterface $request PSR-7 Request
     *
     * @return mixed[]
     */
    abstract protected function validateThenMapAttributes(ServerRequestInterface $request): array;
}