Majora\Framework\Domain\Action\Dal\DalActionTrait

Complexity

Total Complexity

11

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setEventDispatcher()	0	4	1
A	setValidator()	0	4	1
B	assertEntityIsValid()	0	23	4
A	fireEvent()	0	11	2
A	getScopes()	0	4	1
A	normalize()	0	4	1
A	denormalize()	0	4	1

<?php

namespace Majora\Framework\Domain\Action\Dal;

use Majora\Framework\Api\Client\RestApiClient;
use Majora\Framework\Validation\ValidationException;
use Symfony\Component\EventDispatcher\Event;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Serializer\SerializerInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

/**
 * Base trait for Dal actions
 */
trait DalActionTrait
{
    /**
     * @var ValidatorInterface
     */
    protected $validator;

    /**
     * @var EventDispatcherInterface
     */
    protected $eventDispatcher;

    /**
     * define event dispatcher.
     *
     * @param EventDispatcherInterface $eventDispatcher
     */
    public function setEventDispatcher(EventDispatcherInterface $eventDispatcher)
    {
        $this->eventDispatcher = $eventDispatcher;
    }

    /**
     * define validator.
     *
     * @param ValidatorInterface $validator
     */
    public function setValidator(ValidatorInterface $validator)
    {
        $this->validator = $validator;
    }

    /**
     * assert given entity is valid on given scope.
     *
     * @param object       $entity
     * @param string|array $scope
     *
     * @throws ValidationException If given object is invalid on given scope
     */
    protected function assertEntityIsValid($entity, $scope = null)
    {
        if (!$this->validator) {
            throw new \BadMethodCallException(sprintf(
                'Method %s() cannot be used while validator is not configured.',
                __METHOD__
            ));
        }

        $scopes = $scope ? (array) $scope : null;

        $violationList = $this->validator->validate(
            $entity,
            null,
            $scopes
        );

        if (!count($violationList)) {
            return;
        }

        throw new ValidationException($entity, $violationList, $scopes);
    }

    /**
     * fire given event.
     *
     * @param string $eventName
     * @param Event  $event
     *
     * @throws \BadMethodCallException If any event dispatcher set
     */
    protected function fireEvent($eventName, Event $event)
    {
        if (!$this->eventDispatcher) {
            throw new \BadMethodCallException(sprintf(
                'Method %s() cannot be used while event dispatcher is not configured.',
                __METHOD__
            ));
        }

        $this->eventDispatcher->dispatch($eventName, $event);
    }

    /**
     * @see NormalizableInterface::getScopes()
     */
    public static function getScopes()
    {
        return array();
    }

    /**
     * @see NormalizableInterface::normalize()
     */
    public function normalize($scope = 'default')

The parameter $scope is not used and could be removed.

    {
        return array();
    }

    /**
     * @see NormalizableInterface::denormalize()
     */
    public function denormalize(array $data)

The parameter $data is not used and could be removed.

    {
        return $this;
    }
}