Initial xentral_oss_20.3.c9ffacf

classes/Modules/MandatoryFields/Bootstrap.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields;
+
+use Xentral\Core\DependencyInjection\ContainerInterface;
+use Xentral\Modules\MandatoryFields\Service\MandatoryFieldsGateway;
+use Xentral\Modules\MandatoryFields\Service\MandatoryFieldsService;
+use Xentral\Modules\MandatoryFields\Service\MandatoryFieldsValidator;
+
+final class Bootstrap
+{
+    /**
+     * @return array
+     */
+    public static function registerServices(): array
+    {
+        return [
+            'MandatoryFieldsModule' => 'onInitMandatoryFieldsModule',
+        ];
+    }
+
+    /**
+     * @param ContainerInterface $container
+     *
+     * @return MandatoryFieldsModule
+     */
+    public static function onInitMandatoryFieldsModule(ContainerInterface $container): MandatoryFieldsModule
+    {
+        return new MandatoryFieldsModule(
+            self::onInitMandatoryFieldsGateway($container),
+            self::onInitMandatoryFieldsService($container),
+            self::onInitMandatoryFieldsValidator($container)
+        );
+    }
+
+    /**
+     * @param ContainerInterface $container
+     *
+     * @return MandatoryFieldsGateway
+     */
+    private static function onInitMandatoryFieldsGateway(ContainerInterface $container): MandatoryFieldsGateway
+    {
+        return new MandatoryFieldsGateway($container->get('Database'));
+    }
+
+    /**
+     * @param ContainerInterface $container
+     *
+     * @return MandatoryFieldsService
+     */
+    private static function onInitMandatoryFieldsService(ContainerInterface $container): MandatoryFieldsService
+    {
+        return new MandatoryFieldsService($container->get('Database'));
+    }
+
+    /**
+     * @param ContainerInterface $container
+     *
+     * @return MandatoryFieldsValidator
+     */
+    private static function onInitMandatoryFieldsValidator(ContainerInterface $container): MandatoryFieldsValidator
+    {
+        return new MandatoryFieldsValidator(
+            self::onInitMandatoryFieldsGateway($container)
+        );
+    }
+}

classes/Modules/MandatoryFields/Data/MandatoryFieldData.php

@@ -0,0 +1,247 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Data;
+
+use Xentral\Modules\MandatoryFields\Exception\ValidationFailedException;
+
+final class MandatoryFieldData
+{
+
+    /** @var int $id */
+    private $id = 0;
+
+    /** @var string $module */
+    private $module = '';
+
+    /** @var string $action */
+    private $action = '';
+
+    /** @var string $fieldId */
+    private $fieldId = '';
+
+    /** @var string $errorMessage */
+    private $errorMessage = '';
+
+    /** @var string $type */
+    private $type = '';
+
+    /** @var int $minLength */
+    private $minLength = 0;
+
+    /** @var int $maxLength */
+    private $maxLength = 0;
+
+    /** @var bool $mandatory */
+    private $mandatory = false;
+
+    /** @var string $comparator */
+    private $comparator = '';
+
+    /** @var string $compareto */
+    private $compareto = '';
+
+    private function __construct()
+    {
+    }
+
+    /**
+     * @param array $data
+     *
+     * @return array
+     */
+    private static function validate(array $data): array
+    {
+        $errors = [];
+
+        if (!isset($data['module']) || empty($data['module'])) {
+            $errors['module'][] = 'Module is missing.';
+        }
+
+        if (!isset($data['action']) || empty($data['action'])) {
+            $errors['action'][] = 'Action is missing.';
+        }
+
+        if (!isset($data['field_id']) || empty($data['field_id'])) {
+            $errors['field_id'][] = 'Field_id is missing.';
+        }
+
+        if (!isset($data['type']) || empty($data['type'])) {
+            $errors['type'][] = 'Type is missing.';
+        }
+
+        return $errors;
+    }
+
+    /**
+     * @param array $data
+     *
+     * @throws ValidationFailedException
+     *
+     * @return MandatoryFieldData
+     */
+    public static function fromArray(array $data): MandatoryFieldData
+    {
+        $errors = self::validate($data);
+
+        if (!empty($errors)) {
+            throw ValidationFailedException::fromErrors($errors);
+        }
+
+        return self::fromDbState($data);
+    }
+
+    /**
+     * @return array
+     */
+    public function toArray(): array
+    {
+        return [
+            'id'            => $this->id,
+            'module'        => $this->module,
+            'action'        => $this->action,
+            'field_id'      => $this->fieldId,
+            'error_message' => $this->errorMessage,
+            'type'          => $this->type,
+            'min_length'    => $this->minLength,
+            'max_length'    => $this->maxLength,
+            'mandatory'     => $this->mandatory,
+            'comparator'    => $this->comparator,
+            'compareto'     => $this->compareto,
+        ];
+    }
+
+    /**
+     * @param array $data
+     *
+     * @return MandatoryFieldData
+     */
+    public static function fromDbState(array $data): MandatoryFieldData
+    {
+        $mandatoryField = new MandatoryFieldData();
+
+        $mandatoryField->module = $data['module'];
+        $mandatoryField->action = $data['action'];
+        $mandatoryField->fieldId = $data['field_id'];
+        $mandatoryField->type = $data['type'];
+
+        if (isset($data['id'])) {
+            $mandatoryField->id = (int)$data['id'];
+        }
+
+        if (isset($data['error_message'])) {
+            $mandatoryField->errorMessage = $data['error_message'];
+        }
+
+        if (isset($data['min_length'])) {
+            $mandatoryField->minLength = (int)$data['min_length'];
+        }
+
+        if (isset($data['max_length'])) {
+            $mandatoryField->maxLength = (int)$data['max_length'];
+        }
+
+        if (isset($data['mandatory'])) {
+            $mandatoryField->mandatory = (bool)$data['mandatory'];
+        }
+
+        if (isset($data['comparator'])) {
+            $mandatoryField->comparator = $data['comparator'];
+        }
+
+        if (isset($data['compareto'])) {
+            $mandatoryField->compareto = str_replace(',', '.', $data['compareto']);
+        }
+
+        return $mandatoryField;
+    }
+
+    /**
+     * @return int
+     */
+    public function getId(): int
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return string
+     */
+    public function getModule(): string
+    {
+        return $this->module;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAction(): string
+    {
+        return $this->action;
+    }
+
+    /**
+     * @return string
+     */
+    public function getFieldId(): string
+    {
+        return $this->fieldId;
+    }
+
+    /**
+     * @return string
+     */
+    public function getErrorMessage(): string
+    {
+        return $this->errorMessage;
+    }
+
+    /**
+     * @return string
+     */
+    public function getType(): string
+    {
+        return $this->type;
+    }
+
+    /**
+     * @return int
+     */
+    public function getMinLength(): int
+    {
+        return $this->minLength;
+    }
+
+    /**
+     * @return int
+     */
+    public function getMaxLength(): int
+    {
+        return $this->maxLength;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isMandatory(): bool
+    {
+        return $this->mandatory;
+    }
+
+    /**
+     * @return string
+     */
+    public function getComparator(): string
+    {
+        return $this->comparator;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCompareto(): string
+    {
+        return $this->compareto;
+    }
+}

classes/Modules/MandatoryFields/Data/ValidatorResultData.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Data;
+
+final class ValidatorResultData
+{
+    /** @var bool $isError */
+    private $isError;
+
+    /** @var string $message */
+    private $message;
+
+    /**
+     * @param bool   $isError
+     * @param string $message
+     */
+    public function __construct(bool $isError, string $message)
+    {
+        $this->isError = $isError;
+        $this->message = $message;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isError(): bool
+    {
+        return $this->isError;
+    }
+
+    /**
+     * @return string
+     */
+    public function getMessage(): string
+    {
+        return $this->message;
+    }
+
+    /**
+     * @return array
+     */
+    public function toArray(): array
+    {
+        return [
+            'error'   => $this->isError,
+            'message' => $this->message,
+        ];
+    }
+}

classes/Modules/MandatoryFields/Exception/MandatoryFieldExistsException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Exception;
+
+use RuntimeException as SplRuntimeException;
+
+final class MandatoryFieldExistsException extends SplRuntimeException implements MandatoryFieldsExceptionInterface
+{
+}

classes/Modules/MandatoryFields/Exception/MandatoryFieldNotFoundException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Exception;
+
+use RuntimeException as SplRuntimeException;
+
+final class MandatoryFieldNotFoundException extends SplRuntimeException implements MandatoryFieldsExceptionInterface
+{
+}

classes/Modules/MandatoryFields/Exception/MandatoryFieldsExceptionInterface.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Exception;
+
+use Xentral\Core\Exception\ModuleExceptionInterface;
+
+interface MandatoryFieldsExceptionInterface extends ModuleExceptionInterface
+{
+}

classes/Modules/MandatoryFields/Exception/RuntimeException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Exception;
+
+use RuntimeException as SplRuntimeException;
+
+final class RuntimeException extends SplRuntimeException implements MandatoryFieldsExceptionInterface
+{
+}

classes/Modules/MandatoryFields/Exception/UnknownTypeException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Exception;
+
+use RuntimeException as SplRuntimeException;
+
+final class UnknownTypeException extends SplRuntimeException implements MandatoryFieldsExceptionInterface
+{
+}

classes/Modules/MandatoryFields/Exception/ValidationFailedException.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Exception;
+
+use RuntimeException;
+
+final class ValidationFailedException extends RuntimeException implements MandatoryFieldsExceptionInterface
+{
+    /** @var array $errors */
+    private $errors = [];
+
+    /**
+     * @param array $errors
+     *
+     * @return self
+     */
+    public static function fromErrors(array $errors)
+    {
+        $errorString = '';
+        foreach ($errors as $propertyName => $propertyErrors) {
+            $errorString .= implode("\r\n", $propertyErrors);
+        }
+
+        $exception = new self('Validation failed with following errors: ' . "\n\n" . $errorString);
+        $exception->errors = $errors;
+
+        return $exception;
+    }
+
+    /**
+     * @return array
+     */
+    public function getErrors()
+    {
+        return $this->errors;
+    }
+}

classes/Modules/MandatoryFields/MandatoryFieldsModule.php

@@ -0,0 +1,128 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields;
+
+use Xentral\Modules\MandatoryFields\Data\MandatoryFieldData;
+use Xentral\Modules\MandatoryFields\Data\ValidatorResultData;
+use Xentral\Modules\MandatoryFields\Exception\MandatoryFieldExistsException;
+use Xentral\Modules\MandatoryFields\Exception\MandatoryFieldNotFoundException;
+use Xentral\Modules\MandatoryFields\Exception\UnknownTypeException;
+use Xentral\Modules\MandatoryFields\Service\MandatoryFieldsGateway;
+use Xentral\Modules\MandatoryFields\Service\MandatoryFieldsService;
+use Xentral\Modules\MandatoryFields\Service\MandatoryFieldsValidator;
+
+final class MandatoryFieldsModule
+{
+
+    /** @var MandatoryFieldsGateway $gateway */
+    private $gateway;
+
+    /** @var MandatoryFieldsService $service */
+    private $service;
+
+    /** @var MandatoryFieldsValidator $validator */
+    private $validator;
+
+    /**
+     * @param MandatoryFieldsGateway   $gateway
+     * @param MandatoryFieldsService   $service
+     * @param MandatoryFieldsValidator $validator
+     */
+    public function __construct(
+        MandatoryFieldsGateway $gateway,
+        MandatoryFieldsService $service,
+        MandatoryFieldsValidator $validator
+    ) {
+        $this->service = $service;
+        $this->gateway = $gateway;
+        $this->validator = $validator;
+    }
+
+    /**
+     * @param MandatoryFieldData $mandatoryField
+     *
+     * @throws MandatoryFieldExistsException
+     *
+     * @return int
+     */
+    public function createMandatoryField(MandatoryFieldData $mandatoryField): int
+    {
+        $exists = $this->existsMandatoryField(
+            $mandatoryField->getModule(),
+            $mandatoryField->getAction(),
+            $mandatoryField->getFieldId(),
+            $mandatoryField->getType()
+        );
+
+        if ($exists) {
+            throw new MandatoryFieldExistsException('Mandatory field already exists.');
+        }
+
+        return $this->service->create($mandatoryField);
+    }
+
+    /**
+     * @param MandatoryFieldData $mandatoryField
+     *
+     * @throws MandatoryFieldNotFoundException
+     */
+    public function editMandatoryField(MandatoryFieldData $mandatoryField): void
+    {
+        $this->service->edit($mandatoryField);
+    }
+
+    /**
+     * @param string $module
+     * @param string $action
+     * @param string $fieldId
+     * @param string $type
+     *
+     * @return bool
+     */
+    public function existsMandatoryField(string $module, string $action, string $fieldId, string $type): bool
+    {
+        $result = $this->gateway->getMandatoryFieldByParameters($module, $action, $fieldId, $type);
+
+        return !empty($result);
+    }
+
+    /**
+     * @param int $mandatoryFieldId
+     *
+     * @throws MandatoryFieldNotFoundException
+     */
+    public function removeMandatoryFieldById(int $mandatoryFieldId): void
+    {
+        $this->service->removeById($mandatoryFieldId);
+    }
+
+
+    /**
+     * @param int $mandatoryFieldId
+     *
+     * @throws MandatoryFieldNotFoundException
+     *
+     * @return MandatoryFieldData
+     */
+    public function getMandatoryFieldById(int $mandatoryFieldId): MandatoryFieldData
+    {
+        return $this->gateway->getById($mandatoryFieldId);
+    }
+
+    /**
+     * @param string $type
+     * @param string $value
+     * @param int    $mandatoryFieldId
+     *
+     * @throws UnknownTypeException
+     * @throws MandatoryFieldNotFoundException
+     *
+     * @return ValidatorResultData
+     */
+    public function validate(string $type, string $value, int $mandatoryFieldId): ValidatorResultData
+    {
+        return $this->validator->validate($type, $value, $mandatoryFieldId);
+    }
+}

classes/Modules/MandatoryFields/Service/MandatoryFieldsGateway.php

@@ -0,0 +1,223 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Service;
+
+use Xentral\Components\Database\Database;
+use Xentral\Modules\MandatoryFields\Data\MandatoryFieldData;
+use Xentral\Modules\MandatoryFields\Exception\MandatoryFieldNotFoundException;
+
+final class MandatoryFieldsGateway
+{
+    /** @var Database $db */
+    private $db;
+
+    /**
+     * @param Database $db
+     */
+    public function __construct(Database $db)
+    {
+        $this->db = $db;
+    }
+
+    /**
+     * @param string $module
+     * @param string $action
+     * @param string $fieldId
+     * @param string $type
+     *
+     * @return MandatoryFieldData|null
+     */
+    public function getMandatoryFieldByParameters(
+        string $module,
+        string $action,
+        string $fieldId,
+        string $type
+    ): ?MandatoryFieldData {
+        $sql =
+            'SELECT
+                `id`,
+                `module`,
+                `action`,
+                `field_id`,
+                `error_message`,
+                `type`,
+                `min_length`,
+                `max_length`,
+                `mandatory`,
+                `comparator`,
+                `compareto`
+            FROM `mandatory_field` AS `m`
+            WHERE m.module = :module
+            AND m.action = :action
+            AND m.type = :type
+            AND m.field_id = :field_id
+            LIMIT 1';
+
+        $values = [
+            'module'  => $module,
+            'action'  => $action,
+            'field_id' => $fieldId,
+            'type'    => $type,
+        ];
+
+        $data = $this->db->fetchRow($sql, $values);
+
+        if (!empty($data)) {
+            return MandatoryFieldData::fromDbState($data);
+        }
+
+        return null;
+    }
+
+    /**
+     * @param int $mandatoryFieldId
+     *
+     * @throws MandatoryFieldNotFoundException
+     *
+     * @return MandatoryFieldData
+     */
+    public function getById(int $mandatoryFieldId): MandatoryFieldData
+    {
+        $sql =
+            'SELECT
+                `id`,
+                `module`,
+                `action`,
+                `field_id`,
+                `error_message`,
+                `type`,
+                `min_length`,
+                `max_length`,
+                `mandatory`,
+                `comparator`,
+                `compareto`
+            FROM `mandatory_field` AS `m`
+            WHERE m.id = :id
+            LIMIT 1';
+
+        $values = [
+            'id' => $mandatoryFieldId,
+        ];
+
+        $data = $this->db->fetchRow($sql, $values);
+
+        if (empty($data)) {
+            throw new MandatoryFieldNotFoundException('No mandatory field record with the id:' . $mandatoryFieldId);
+        }
+
+        return MandatoryFieldData::fromDbState($data);
+    }
+
+    /**
+     * @param string $customernumber
+     *
+     * @return bool
+     */
+    public function isAddressWithCustomerNumberActive(string $customerNumber): bool
+    {
+        $sql =
+            'SELECT a.id 
+            FROM `adresse` AS `a` 
+            WHERE a.kundennummer = :customer_number 
+            AND a.kundennummer != \'\' 
+            AND a.geloescht != 1';
+
+        $data = $this->db->fetchRow($sql, ['customer_number' => $customerNumber]);
+
+        if (empty($data)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param string $employeeNumber
+     *
+     * @return bool
+     */
+    public function isAddressWithEmployeeNumberActive(string $employeeNumber): bool
+    {
+        $sql =
+            'SELECT a.id 
+            FROM `adresse` AS `a` 
+            WHERE a.mitarbeiternummer = :employee_number 
+            AND a.mitarbeiternummer != \'\' 
+            AND a.geloescht != 1';
+
+        $data = $this->db->fetchRow($sql, ['employee_number' => $employeeNumber]);
+
+        if (empty($data)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param string $articleNumber
+     *
+     * @return bool
+     */
+    public function isArticleWithNumberActive(string $articleNumber): bool
+    {
+        $sql =
+            'SELECT a.id 
+            FROM `artikel` AS `a` 
+            WHERE a.nummer = :article_number 
+            AND a.nummer != \'\' 
+            AND a.geloescht != 1 ';
+
+        $data = $this->db->fetchRow($sql, ['article_number' => $articleNumber]);
+
+        if (empty($data)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param string $documentNumber
+     *
+     * @return bool
+     */
+    public function isOrderWithDocumentNumberActive(string $documentNumber): bool
+    {
+        $sql =
+            'SELECT a.id 
+            FROM `auftrag` AS `a` 
+            WHERE a.belegnr = :document_number';
+
+        $data = $this->db->fetchRow($sql, ['document_number' => $documentNumber]);
+
+        if (empty($data)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param string $documentNumber
+     *
+     * @return bool
+     */
+    public function isInvoiceWithDocumentNumberActive(string $documentNumber): bool
+    {
+        $sql =
+            'SELECT r.id 
+            FROM `rechnung` AS `r` 
+            WHERE r.belegnr = :document_number';
+
+        $data = $this->db->fetchRow($sql, ['document_number' => $documentNumber]);
+
+        if (empty($data)) {
+            return false;
+        }
+
+        return true;
+    }
+}

classes/Modules/MandatoryFields/Service/MandatoryFieldsService.php

@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Service;
+
+use Xentral\Components\Database\Database;
+use Xentral\Modules\MandatoryFields\Data\MandatoryFieldData;
+use Xentral\Modules\MandatoryFields\Exception\MandatoryFieldNotFoundException;
+use Xentral\Modules\MandatoryFields\Exception\RuntimeException;
+
+final class MandatoryFieldsService
+{
+    /** @var Database $db */
+    private $db;
+
+    /**
+     * @param Database $db
+     */
+    public function __construct(Database $db)
+    {
+        $this->db = $db;
+    }
+
+    /**
+     * @param MandatoryFieldData $mandatoryField
+     *
+     * @return int
+     */
+    public function create(MandatoryFieldData $mandatoryField): int
+    {
+        $sql =
+            'INSERT INTO `mandatory_field` (
+                `module`,
+                `action`,
+                `field_id`,
+                `error_message`,
+                `type`,
+                `min_length`,
+                `max_length`,
+                `mandatory`,
+                `comparator`,
+                `compareto`
+            ) 
+            VALUES (
+                :module,
+                :action,
+                :field_id,
+                :error_message,
+                :type,
+                :min_length,
+                :max_length,
+                :mandatory,
+                :comparator,
+                :compare_to    
+            )';
+        $values = [
+            'module'        => $mandatoryField->getModule(),
+            'action'        => $mandatoryField->getAction(),
+            'field_id'      => $mandatoryField->getFieldId(),
+            'error_message' => $mandatoryField->getErrorMessage(),
+            'type'          => $mandatoryField->getType(),
+            'min_length'    => $mandatoryField->getMinLength(),
+            'max_length'    => $mandatoryField->getMaxLength(),
+            'mandatory'     => $mandatoryField->isMandatory(),
+            'comparator'    => $mandatoryField->getComparator(),
+            'compare_to'    => $mandatoryField->getCompareto(),
+        ];
+
+        $this->db->perform($sql, $values);
+
+        return $this->db->lastInsertId();
+    }
+
+    /**
+     * @param MandatoryFieldData $mandatoryField
+     *
+     * @throws MandatoryFieldNotFoundException
+     */
+    public function edit(MandatoryFieldData $mandatoryField): void
+    {
+        $sql = 'SELECT m.id FROM `mandatory_field` AS `m` WHERE m.id = :id';
+        $data = $this->db->fetchRow($sql, ['id' => $mandatoryField->getId()]);
+
+        if (empty($data)) {
+            throw new MandatoryFieldNotFoundException('The record can not be edited: ' . $mandatoryField->getId());
+        }
+
+        $sql =
+            'UPDATE `mandatory_field` SET
+                `module` = :module,
+                `action` = :action,
+                `field_id` = :field_id,
+                `error_message` = :error_message,
+                `type` = :type,
+                `min_length` = :min_length,
+                `max_length` = :max_length,
+                `mandatory` = :mandatory,
+                `comparator` = :comparator,
+                `compareto` = :compare_to
+            WHERE `id` = :id';
+
+        $values = [
+            'id'            => $mandatoryField->getId(),
+            'module'        => $mandatoryField->getModule(),
+            'action'        => $mandatoryField->getAction(),
+            'field_id'      => $mandatoryField->getFieldId(),
+            'error_message' => $mandatoryField->getErrorMessage(),
+            'type'          => $mandatoryField->getType(),
+            'min_length'    => $mandatoryField->getMinLength(),
+            'max_length'    => $mandatoryField->getMaxLength(),
+            'mandatory'     => $mandatoryField->isMandatory(),
+            'comparator'    => $mandatoryField->getComparator(),
+            'compare_to'    => $mandatoryField->getCompareto(),
+        ];
+
+        $this->db->perform($sql, $values);
+    }
+
+    /**
+     * @param int $mandatoryFieldId
+     *
+     * @throws MandatoryFieldNotFoundException
+     */
+    public function removeById(int $mandatoryFieldId): void
+    {
+        $sql = 'SELECT m.id FROM `mandatory_field` AS `m` WHERE m.id = :id';
+        $data = $this->db->fetchRow($sql, ['id' => $mandatoryFieldId]);
+
+        if (empty($data)) {
+            throw new MandatoryFieldNotFoundException('The Id does not exist: ' . $mandatoryFieldId);
+        }
+
+        $sql = 'DELETE FROM `mandatory_field` WHERE `id` = :id';
+        $numAffected = (int)$this->db->fetchAffected($sql, ['id' => $mandatoryFieldId]);
+
+        if ($numAffected === 0) {
+            throw new RuntimeException('Mandatory field could not be deleted, id: ' . $mandatoryFieldId);
+        }
+    }
+}

classes/Modules/MandatoryFields/Service/MandatoryFieldsValidator.php

@@ -0,0 +1,323 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xentral\Modules\MandatoryFields\Service;
+
+use Xentral\Modules\MandatoryFields\Data\MandatoryFieldData;
+use Xentral\Modules\MandatoryFields\Data\ValidatorResultData;
+use Xentral\Modules\MandatoryFields\Exception\MandatoryFieldNotFoundException;
+use Xentral\Modules\MandatoryFields\Exception\UnknownTypeException;
+
+final class MandatoryFieldsValidator
+{
+    /** @var MandatoryFieldsGateway $gateway */
+    private $gateway;
+
+    /**
+     * @param MandatoryFieldsGateway $gateway
+     */
+    public function __construct(
+        MandatoryFieldsGateway $gateway
+    ) {
+        $this->gateway = $gateway;
+    }
+
+    /**
+     * @param string $type
+     * @param string $value
+     * @param int    $mandatoryFieldId
+     *
+     * @throws UnknownTypeException
+     * @throws MandatoryFieldNotFoundException
+     *
+     * @return ValidatorResultData
+     */
+    public function validate(string $type, string $value, int $mandatoryFieldId): ValidatorResultData
+    {
+        $mandatoryField = $this->gateway->getById($mandatoryFieldId);
+
+        if ($mandatoryField->isMandatory() || (!$mandatoryField->isMandatory() && $value != '')) {
+            switch ($type) {
+                case 'kunde':
+                    $result = $this->checkCustomer($value);
+                    break;
+                case 'mitarbeiter':
+                    $result = $this->checkEmployee($value);
+                    break;
+                case 'artikel':
+                    $result = $this->checkArticle($value);
+                    break;
+                case 'rechnung':
+                    $result = $this->checkInvoice($value);
+                    break;
+                case 'auftrag':
+                    $result = $this->checkOrder($value);
+                    break;
+                case 'text':
+                    $result = $this->checkText($value, $mandatoryField);
+                    break;
+                case 'ganzzahl':
+                    $result = $this->checkInteger($value, $mandatoryField);
+                    break;
+                case 'dezimalzahl':
+                    $result = $this->checkDecimal($value, $mandatoryField);
+                    break;
+                case 'datum':
+                    $result = $this->checkDate($value);
+                    break;
+                case 'e-mail':
+                    $result = $this->checkEmail($value);
+                    break;
+                default:
+                    throw new UnknownTypeException('Type not known: ' . $type);
+            }
+
+            $error = $result['error'];
+            $message = $result['default'];
+
+            if (!empty($mandatoryField->getErrorMessage())) {
+                $message = $mandatoryField->getErrorMessage();
+            }
+
+            return new ValidatorResultData($error, $message);
+        }
+
+        return new ValidatorResultData(false, '');
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return array
+     */
+    private function checkCustomer(string $value): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (!$this->gateway->isAddressWithCustomerNumberActive($value)) {
+            $data['default'] = 'Kunde nicht gültig.';
+            $data['error'] = true;
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return array
+     */
+    private function checkEmployee(string $value): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (!$this->gateway->isAddressWithEmployeeNumberActive($value)) {
+            $data['default'] = 'Mitarbeiter nicht gültig.';
+            $data['error'] = true;
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return array
+     */
+    private function checkArticle(string $value): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (!$this->gateway->isArticleWithNumberActive($value)) {
+            $data['default'] = 'Artikel-Nr. nicht gültig.';
+            $data['error'] = true;
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return array
+     */
+    private function checkInvoice(string $value): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (!$this->gateway->isInvoiceWithDocumentNumberActive($value)) {
+            $data['default'] = 'Rechnungs-Nr. nicht gültig.';
+            $data['error'] = true;
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return array
+     */
+    private function checkOrder(string $value): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (!$this->gateway->isOrderWithDocumentNumberActive($value)) {
+            $data['default'] = 'Auftrags-Nr. nicht gültig.';
+            $data['error'] = true;
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string             $value
+     * @param MandatoryFieldData $mandatoryField
+     *
+     * @return array
+     */
+    private function checkText(string $value, MandatoryFieldData $mandatoryField): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        $minLength = $mandatoryField->getMinLength();
+        $maxLength = $mandatoryField->getMaxLength();
+
+
+        if ($minLength > 0) {
+            if (strlen($value) < $minLength) {
+                $data['default'] = 'Eingabe zu kurz';
+                $data['error'] = true;
+            }
+        }
+
+        if ($maxLength > 0) {
+            if (strlen($value) > $maxLength) {
+                $data['default'] = 'Eingabe zu lang';
+                $data['error'] = true;
+            }
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string             $value
+     * @param MandatoryFieldData $mandatoryField
+     *
+     * @return array
+     */
+    private function checkInteger(string $value, MandatoryFieldData $mandatoryField): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (filter_var($value, FILTER_VALIDATE_INT) === false) {
+            $data['default'] = 'Keine Ganzzahl';
+            $data['error'] = true;
+        } else {
+            $data = $this->validateNumbers($mandatoryField, $data, $value);
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string             $value
+     * @param MandatoryFieldData $mandatoryField
+     *
+     * @return array
+     */
+    private function checkDecimal(string $value, MandatoryFieldData $mandatoryField): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (strpos($value, '.') === false && strpos($value, ',') === false) {
+            $data['default'] = 'Keine Dezimalzahl';
+            $data['error'] = true;
+        } else {
+            $data = $this->validateNumbers($mandatoryField, $data, $value);
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return array
+     */
+    private function checkDate(string $value): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        $datum = str_replace('.', '-', $value);
+        $datum = str_replace('/', '-', $datum);
+
+        if (!(bool)strtotime($datum)) {
+            $data['default'] = 'Datumsformat nicht gültig.';
+            $data['error'] = true;
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return array
+     */
+    private function checkEmail(string $value): array
+    {
+        $data['default'] = '';
+        $data['error'] = false;
+
+        if (filter_var($value, FILTER_VALIDATE_EMAIL) === false) {
+            $data['default'] = 'E-Mail Adressformat nicht gültig.';
+            $data['error'] = true;
+        }
+
+        return $data;
+    }
+
+
+    /**
+     * @param MandatoryFieldData $mandatoryField
+     * @param array              $data
+     * @param string             $value
+     *
+     * @return array
+     */
+    private function validateNumbers(MandatoryFieldData $mandatoryField, array $data, string $value): array
+    {
+        $comparator = $mandatoryField->getComparator();
+        $compareTo = (float)$mandatoryField->getCompareto();
+        $isValid = true;
+
+        if ($comparator != '') {
+            if ($comparator === 'equals') {
+                $isValid = (float)$value == $compareTo;
+            } elseif ($comparator === 'lowerthan') {
+                $isValid = (float)$value < $compareTo;
+            } elseif ($comparator === 'greaterthan') {
+                $isValid = (float)$value > $compareTo;
+            }
+
+            if (!$isValid) {
+                $data['error'] = true;
+                $data['default'] = 'Die Zahl entspricht nicht den Vorgaben.';
+            }
+        }
+
+        return $data;
+    }
+}

classes/Modules/MandatoryFields/www/js/mandatoryfields.js

@@ -0,0 +1,545 @@
+
+/**
+ * Für die Bedienung der Modul-Oberfläche
+ */
+var MandatoryFieldsUi = (function ($) {
+    'use strict';
+
+    var me = {
+
+        isInitialized: false,
+
+        storage: {
+            $table: null,
+            dataTable: null,
+            $editDialog: null
+        },
+
+        /**
+         * @return void
+         */
+        init: function () {
+            if (me.isInitialized === true) {
+                return;
+            }
+
+            me.storage.$table = $('#mandatoryfields_list');
+            me.storage.dataTable = me.storage.$table.dataTable();
+            me.storage.$editDialog = $('#editMandatoryFields');
+
+            if (me.storage.$table.length === 0 || me.storage.$editDialog.length === 0) {
+                throw 'Could not initialize MandatoryFieldsUi. Required elements are missing.';
+            }
+
+            me.initDialog();
+            me.registerEvents();
+
+            me.isInitialized = true;
+        },
+
+        /**
+         * @return {void}
+         */
+        initDialog: function () {
+            me.storage.$editDialog.dialog({
+                modal: true,
+                bgiframe: true,
+                closeOnEscape: false,
+                minWidth: 550,
+                maxHeight: 700,
+                autoOpen: false,
+                buttons: [{
+                    text: 'ABBRECHEN',
+                    click: function () {
+                        me.resetEditDialog();
+                        me.closeEditDialog();
+                    }
+                }, {
+                    text: 'SPEICHERN',
+                    click: function () {
+                        me.saveItem();
+                    }
+                }],
+                open: function () {
+                    $('#mandatoryfield_module').focus(); // Focus first input element
+                },
+                close: function () {
+                    me.resetEditDialog();
+                }
+            });
+        },
+
+        /**
+         * @return {void}
+         */
+        registerEvents: function () {
+
+            // Eintrag bearbeiten
+            $(document).on('click', '.mandatoryfields-edit', function (e) {
+                e.preventDefault();
+                var fieldId = $(this).data('mandatoryfields-id');
+                me.editItem(fieldId);
+            });
+
+            // Eintrag löschen
+            $(document).on('click', '.mandatoryfields-delete', function (e) {
+                e.preventDefault();
+                var fieldId = $(this).data('mandatoryfields-id');
+                me.deleteItem(fieldId);
+            });
+
+            $(document).on('change', '#mandatoryfield_type', function (e) {
+                me.showHideElements('mandatoryfield_type',$(this).val());
+            });
+        },
+
+        /**
+         * @return {void}
+         */
+        createItem: function () {
+            if (me.isInitialized === false) {
+                me.init();
+            }
+            me.resetEditDialog();
+            me.openEditDialog();
+        },
+
+        /**
+         *
+         * @param {string} elementName
+         * @param {string} elementValue
+         */
+        showHideElements: function (elementName, elementValue) {
+
+            if(elementName==='mandatoryfield_type'){
+                if(elementValue==='text'){
+                    $('.min_max_length').show();
+                }
+                else{
+                    $('.min_max_length').hide();
+                }
+
+                if(
+                    elementValue==='ganzzahl' ||
+                    elementValue==='dezimalzahl'
+                ){
+                    $('.comparator').show();
+                }
+                else{
+                    $('.comparator').hide();
+                }
+            }
+        },
+
+        /**
+         * @param {number} fieldId
+         *
+         * @return {void}
+         */
+        editItem: function (fieldId) {
+            fieldId = parseInt(fieldId);
+            if (isNaN(fieldId) || fieldId <= 0) {
+                return;
+            }
+
+            $.ajax({
+                url: 'index.php?module=mandatoryfields&action=edit&cmd=get',
+                data: {
+                    id: fieldId
+                },
+                method: 'post',
+                dataType: 'json',
+                beforeSend: function () {
+                    App.loading.open();
+                },
+                success: function (data) {
+                    me.storage.$editDialog.find('#mandatoryfield_entry_id').val(data.id);
+                    me.storage.$editDialog.find('#mandatoryfield_module').val(data.module);
+                    me.storage.$editDialog.find('#mandatoryfield_action').val(data.action);
+                    me.storage.$editDialog.find('#mandatoryfield_field_id').val(data.field_id);
+                    me.storage.$editDialog.find('#mandatoryfield_error_message').val(data.error_message);
+                    me.storage.$editDialog.find('#mandatoryfield_type').val(data.type);
+                    me.storage.$editDialog.find('#mandatoryfield_min_length').val(data.min_length);
+                    me.storage.$editDialog.find('#mandatoryfield_max_length').val(data.max_length);
+                    me.storage.$editDialog.find('#mandatoryfield_mandatory').prop('checked', data.mandatory == 1);
+                    me.storage.$editDialog.find('#mandatoryfield_comparator').val(data.comparator);
+                    me.storage.$editDialog.find('#mandatoryfield_compareto').val(data.compareto);
+
+                    me.showHideElements('mandatoryfield_type',data.type);
+
+                    App.loading.close();
+                    me.storage.$editDialog.dialog('open');
+                }
+            });
+        },
+
+        /**
+         * @return {void}
+         */
+        saveItem: function () {
+            $.ajax({
+                url: 'index.php?module=mandatoryfields&action=save',
+                data: {
+                    // Alle Felder die fürs Editieren vorhanden sind
+                    id: $('#mandatoryfield_entry_id').val(),
+                    module: $('#mandatoryfield_module').val(),
+                    action: $('#mandatoryfield_action').val(),
+                    fieldId: $('#mandatoryfield_field_id').val(),
+                    errorMessage: $('#mandatoryfield_error_message').val(),
+                    type: $('#mandatoryfield_type').val(),
+                    minLength: $('#mandatoryfield_min_length').val(),
+                    maxLength: $('#mandatoryfield_max_length').val(),
+                    mandatory: $('#mandatoryfield_mandatory').prop('checked') ? 1 : 0,
+                    comparator: $('#mandatoryfield_comparator').val(),
+                    compareto: $('#mandatoryfield_compareto').val(),
+                },
+                method: 'post',
+                dataType: 'json',
+                beforeSend: function () {
+                    App.loading.open();
+                },
+                success: function (data) {
+                    App.loading.close();
+                    if (data.success === true) {
+                        me.resetEditDialog();
+                        me.reloadDataTable();
+                        me.closeEditDialog();
+                    }
+                    if (data.success === false) {
+                        alert(data.error);
+                    }
+                }
+            });
+        },
+
+        /**
+         * @param {number} fieldId
+         *
+         * @return {void}
+         */
+        deleteItem: function (fieldId) {
+            var confirmValue = confirm('Wirklich löschen?');
+            if (confirmValue === false) {
+                return;
+            }
+
+            $.ajax({
+                url: 'index.php?module=mandatoryfields&action=delete',
+                data: {
+                    id: fieldId
+                },
+                method: 'post',
+                dataType: 'json',
+                beforeSend: function () {
+                    App.loading.open();
+                },
+                success: function (data) {
+                    if (data.success === true) {
+                        me.reloadDataTable();
+                    }
+                    if (data.success === false) {
+                        alert('Unbekannter Fehler beim Löschen.');
+                    }
+                    App.loading.close();
+                }
+            });
+        },
+
+        /**
+         * @return void
+         */
+        openEditDialog: function () {
+            me.storage.$editDialog.dialog('open');
+        },
+
+        /**
+         * @return void
+         */
+        closeEditDialog: function () {
+            me.storage.$editDialog.dialog('close');
+        },
+
+        /**
+         * @return void
+         */
+        resetEditDialog: function () {
+            me.storage.$editDialog.find('#mandatoryfield_entry_id').val('');
+            me.storage.$editDialog.find('#mandatoryfield_module').val('');
+            me.storage.$editDialog.find('#mandatoryfield_action').val('');
+            me.storage.$editDialog.find('#mandatoryfield_field_id').val('');
+            me.storage.$editDialog.find('#mandatoryfield_error_message').val('');
+            var type = document.getElementById('mandatoryfield_type');
+            type.selectedIndex = 0;
+            me.storage.$editDialog.find('#mandatoryfield_min_length').val('');
+            me.storage.$editDialog.find('#mandatoryfield_max_length').val('');
+            me.storage.$editDialog.find('#mandatoryfield_mandatory').prop('checked', true);
+            me.storage.$editDialog.find('#mandatoryfield_comparator').val('');
+            me.storage.$editDialog.find('#mandatoryfield_compareto').val('');
+
+            me.showHideElements('mandatoryfield_type','text');
+        },
+
+        /**
+         * @return {void}
+         */
+        reloadDataTable: function () {
+            me.storage.dataTable.api().ajax.reload();
+        }
+    };
+
+    return {
+        init: me.init,
+        createItem: me.createItem
+    };
+
+})(jQuery);
+
+
+/**
+ * Prüft Formular-Pflichtfelder
+ */
+var MandatoryFieldsValidator = (function () {
+    'use strict';
+
+    var me = {
+
+        storage: {
+            $fields: [],
+            fieldConfig: [],
+            debugging: false,
+            $notificationKeys:[],
+        },
+
+        init: function () {
+            me.log('init');
+            var $jsonElem = $('#mandatory-fields-json');
+            if ($jsonElem.length === 0) {
+                return;
+            }
+
+            try {
+                var jsonData = JSON.parse($jsonElem.html());
+            } catch (e) {
+                console.error('Could not initialize MandatoryFieldsValidator. JSON data is malformed.');
+                return;
+            }
+
+            me.log('init jsonData', jsonData);
+            me.storage.fieldConfig = jsonData;
+            if (me.storage.fieldConfig.length === 0) {
+                return;
+            }
+
+            me.registerFields();
+            me.registerEvents();
+        },
+
+        registerEvents: function () {
+
+            var selectors = [
+                'input[type=\'button\']',
+                '.publish',
+                '.ui-dialog-buttonset .ui-button'
+            ];
+
+            $(document).on('click', selectors.join(','), function(e) {
+                if(!me.validateAll(e)){
+                    e.preventDefault();
+                }
+            });
+
+            $(document).on('submit', 'form', function (e) {
+                return me.validateAll(e);
+            });
+        },
+
+        /**
+         * Pflichtfelder mit Data-Attributen und Events für Validierung versehen
+         */
+        registerFields: function () {
+            var fields = Array.from(me.storage.fieldConfig);
+            $.each(fields, function (index, field) {
+                var $elem = $(field.cssSelector);
+                if ($elem.length === 0) {
+                    console.warn('MandatoryFieldsValidator: Could not find element "' + field.cssSelector + '"');
+                    return;
+                }
+
+                // Feld-Instanz merken
+                me.storage.$fields.push($elem);
+
+                // Data-Attribute setzen
+                $elem.data('validator-id', field.id);
+                $elem.data('validator-rule', field.rule);
+
+                // Blur-Event setzen
+                $elem.on('blur', function () {
+                    me.validateField($(this));
+                });
+                if(field.isMandatory){
+                    me.validateFieldOnServerSide($elem).done(function (validationResult) {
+                        var isValid = !validationResult.error
+                        if (!isValid) {
+                            $elem.addClass('validator_field_warning');
+                        }
+                    });
+                }
+            });
+        },
+
+        /**
+         * @param {Event} event
+         */
+        validateAll: function (event) {
+            me.log('validateAll', event);
+            var allValid = true;
+            var $lastInvalidField;
+
+            // Registrierte Felder durchlaufen und einzeln prüfen
+            $.each(me.storage.$fields, function (index, $field) {
+
+                // Feld benötigt Validierung
+                if (me.validateField($field) === false) {
+                    $lastInvalidField = $field;
+                    allValid = false;
+                }
+            });
+
+            // Bei Fehler > Event abbrechen und fehlerhaftes Feld anscrollen
+            if (allValid === false) {
+                me.scrollToField($lastInvalidField);
+                return false;
+            }
+
+            me.log('validateAll done', {allValid:allValid});
+            return true;
+        },
+
+        /**
+         * @param {jQuery} $field
+         *
+         * @return {boolean} true if valid; false if invalid
+         */
+        validateField: function ($field) {
+            me.log('validateField #' + $field.attr('id'));
+            var isValid = true;
+
+            me.validateFieldOnServerSide($field).done(function (validationResult) {
+                me.log('validateFieldOnServerSide doneXHR #' + $field.attr('id'), validationResult);
+                isValid = !validationResult.error
+                if (!isValid) {
+                    me.displayErrorMessage($field, validationResult.message);
+                }
+            });
+
+            // Keine Fehler > Vorherige Fehlermeldung entfernen
+            if (isValid === true) {
+                me.hideErrorMessage($field);
+                $field.removeClass('validator_field_warning');
+            }
+
+            return isValid;
+        },
+
+        /**
+         * @param {jQuery} $field
+         *
+         * @return {jqXHR}
+         */
+        validateFieldOnServerSide: function ($field) {
+            me.log('validateFieldOnServerSide preXHR #' + $field.attr('id'));
+            var fieldValue = $field.val();
+            var fieldId = $field.data('validator-id');
+            var rule = $field.data('validator-rule');
+
+            return jQuery.ajax({
+                type: 'POST',
+                url: 'index.php?module=ajax&action=validator',
+                data: {rule: rule, value: fieldValue, mandatoryid: fieldId},
+                dataType: 'json',
+                async: false
+            });
+        },
+
+        /**
+         * @param {jQuery} $field
+         * @param {string} message
+         */
+        displayErrorMessage: function ($field, message) {
+
+            var keys = Notify.keys();
+            var notificationKey = me.storage.$notificationKeys[$field.attr('id')];
+
+            if ($field.hasClass('validator_field_error') && keys.includes(notificationKey)) {
+                me.log('displayErrorMessage cancelled #' + $field.attr('id'));
+                return; // Fehlermeldung wird schon angezeigt
+            }
+            me.log('displayErrorMessage #' + $field.attr('id'), {message:message});
+
+            Notify.create('error', 'Pflichtfeld', message,true);
+            keys = Notify.keys();
+
+            me.storage.$notificationKeys[$field.attr('id')] = keys[keys.length-1];
+
+            $field.removeClass('validator_field_warning');
+            $field.addClass('validator_field_error');
+        },
+
+        /**
+         * @param {jQuery} $field
+         */
+        hideErrorMessage: function ($field) {
+            me.log('hideErrorMessage #' + $field.attr('id'));
+            $field.removeClass('validator_field_error');
+
+            var key = me.storage.$notificationKeys[$field.attr('id')];
+            Notify.close(key);
+        },
+
+        /**
+         * @param {jQuery} $field
+         */
+        scrollToField: function ($field) {
+            if (typeof $field !== 'object' || !$field instanceof jQuery) {
+                return;
+            }
+
+            me.log('scrollToField #' + $field.attr('id'));
+            var offsetTop = $field.offset().top;
+            var windowHeight = $(window).height();
+            $('html, body').clearQueue().animate({
+                scrollTop: offsetTop - (windowHeight / 2)
+            }, 'slow');
+        },
+
+        /**
+         * @param {string} message
+         * @param {object} context
+         */
+        log: function (message, context) {
+            if (typeof me.storage.debugging === 'undefined' || me.storage.debugging !== true) {
+                return;
+            }
+
+            if (typeof context !== 'undefined') {
+                console.log('MandatoryFieldsValidator: ' + message, context);
+            } else {
+                console.log('MandatoryFieldsValidator: ' + message);
+            }
+        }
+    };
+
+    return {
+        init: me.init
+    };
+
+})(jQuery);
+
+
+$(document).ready(function () {
+    if ($('#mandatoryfields_list').length > 0) {
+        MandatoryFieldsUi.init();
+    }
+
+    MandatoryFieldsValidator.init();
+});