CuyZ\Notiz\Core\Exception\InvalidClassException

Complexity

Total Complexity

10

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	eventPropertyBuilderMissingInterface()	0	6	1
A	channelSettingsMissingInterface()	0	6	1
A	eventConfigurationFlexFormProviderMissingInterface()	0	6	1
A	definitionProcessorHasMissingInterface()	0	6	1
A	notificationProcessorWrongParent()	0	6	1
A	notificationMissingInterface()	0	6	1
A	tagServicePropertyWrongParent()	0	6	1
A	notificationSettingsMissingInterface()	0	6	1
A	eventHasMissingInterface()	0	6	1
A	definitionSourceHasMissingInterface()	0	6	1

<?php
declare(strict_types=1);

/*
 * Copyright (C)
 * Nathan Boiron <nathan.boiron@gmail.com>
 * Romain Canon <romain.hydrocanon@gmail.com>
 *
 * This file is part of the TYPO3 NotiZ project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace CuyZ\Notiz\Core\Exception;

use CuyZ\Notiz\Core\Channel\Settings\ChannelSettings;
use CuyZ\Notiz\Core\Definition\Builder\Component\Processor\DefinitionProcessor;
use CuyZ\Notiz\Core\Definition\Builder\Component\Source\DefinitionSource;
use CuyZ\Notiz\Core\Event\Configuration\FlexForm\EventFlexFormProvider;
use CuyZ\Notiz\Core\Event\Event;
use CuyZ\Notiz\Core\Notification\Notification;
use CuyZ\Notiz\Core\Notification\Processor\NotificationProcessor;
use CuyZ\Notiz\Core\Notification\Settings\NotificationSettings;
use CuyZ\Notiz\Core\Property\Builder\PropertyBuilder;
use CuyZ\Notiz\Core\Property\PropertyEntry;

class InvalidClassException extends NotizException
{
    const DEFINITION_SOURCE_MISSING_INTERFACE = 'The definition source class `%s` must implement the interface `%s`.';

    const DEFINITION_PROCESSOR_MISSING_INTERFACE = 'The definition processor class `%s` must implement the interface `%s`.';

    const EVENT_CLASS_MISSING_INTERFACE = 'The event class `%s` must implement the interface `%s`.';

    const TAG_SERVICE_PROPERTY_WRONG_PARENT = 'The given property class `%s` for identifier `%s` must extend the class `%s`.';

    const NOTIFICATION_MISSING_INTERFACE = 'The notification class `%s` must implement the interface `%s`.';

    const NOTIFICATION_PROCESSOR_WRONG_PARENT = 'The processor class of the notification `%s` must extend the class `%s` (given class is `%s`).';

    const NOTIFICATION_SETTINGS_MISSING_INTERFACE = 'The notification settings class `%s` must implement the interface `%s`.';

    const EVENT_CONFIGURATION_FLEX_FORM_PROVIDER_MISSING_INTERFACE = 'The FlexForm provider class `%s` must implement the interface `%s`.';

    const CHANNEL_SETTINGS_MISSING_INTERFACE = 'The channel settings class `%s` must implement the interface `%s`.';

    const EVENT_PROPERTY_BUILDER_MISSING_INTERFACE = 'The property builder `%s` must implement the interface `%s`.';

    /**
     * @param string $className
     * @return self
     */
    public static function definitionSourceHasMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::DEFINITION_SOURCE_MISSING_INTERFACE,
            1503849499,
            [$className, DefinitionSource::class]
        );
    }

    /**
     * @param string $className
     * @return self
     */
    public static function definitionProcessorHasMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::DEFINITION_PROCESSOR_MISSING_INTERFACE,
            1503850131,
            [$className, DefinitionProcessor::class]
        );
    }

    /**
     * @param string $className
     * @return self
     */
    public static function eventHasMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::EVENT_CLASS_MISSING_INTERFACE,
            1503873348,
            [$className, Event::class]
        );
    }

    /**
     * @param string $propertyType
     * @param string $identifier
     * @return self
     */
    public static function tagServicePropertyWrongParent(string $propertyType, string $identifier): self
    {
        return self::makeNewInstance(
            self::TAG_SERVICE_PROPERTY_WRONG_PARENT,
            1504167339,
            [$propertyType, $identifier, PropertyEntry::class]
        );
    }

    /**
     * @param string $className
     * @return self
     */
    public static function notificationMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::NOTIFICATION_MISSING_INTERFACE,
            1505821532,
            [$className, Notification::class]
        );
    }

    /**
     * @param string $notificationClassName
     * @param string $processorClassName
     * @return self
     */
    public static function notificationProcessorWrongParent(string $notificationClassName, string $processorClassName): self
    {
        return self::makeNewInstance(
            self::NOTIFICATION_PROCESSOR_WRONG_PARENT,
            1505829694,
            [$notificationClassName, NotificationProcessor::class, $processorClassName]
        );
    }

    /**
     * @param string $className
     * @return self
     */
    public static function notificationSettingsMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::NOTIFICATION_SETTINGS_MISSING_INTERFACE,
            1506245423,
            [$className, NotificationSettings::class]
        );
    }

    /**
     * @param string $className
     * @return self
     */
    public static function eventConfigurationFlexFormProviderMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::EVENT_CONFIGURATION_FLEX_FORM_PROVIDER_MISSING_INTERFACE,
            1506952217,
            [$className, EventFlexFormProvider::class]
        );
    }

    /**
     * @param string $className
     * @return self
     */
    public static function channelSettingsMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::CHANNEL_SETTINGS_MISSING_INTERFACE,
            1507409177,
            [$className, ChannelSettings::class]
        );
    }

    /**
     * @param string $className
     * @return self
     */
    public static function eventPropertyBuilderMissingInterface(string $className): self
    {
        return self::makeNewInstance(
            self::EVENT_PROPERTY_BUILDER_MISSING_INTERFACE,
            1519756764,
            [$className, PropertyBuilder::class]
        );
    }
}