class.ilADT.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
abstract class ilADT
{
    protected ilADTDefinition $definition;
 
    protected ilLanguage $lng;
 
    protected array $validation_errors = []; // [array]
 
    public const ADT_VALIDATION_ERROR_NULL_NOT_ALLOWED = "adt1";
 
    // text-based
    public const ADT_VALIDATION_ERROR_MAX_LENGTH = "adt2";
 
    // multi
    public const ADT_VALIDATION_ERROR_MAX_SIZE = "adt3";
 
    // number-based
    public const ADT_VALIDATION_ERROR_MIN = "adt4";
    public const ADT_VALIDATION_ERROR_MAX = "adt5";
 
    // date-based
    public const ADT_VALIDATION_DATE = "adt6";
 
    // invalid target node for internal link
    public const ADT_VALIDATION_ERROR_INVALID_NODE = 'adt7';
 
    public function __construct(ilADTDefinition $a_def)
    {
        global $DIC;
        $this->setDefinition($a_def);
        $this->reset();
 
        $this->lng = $DIC->language();
    }
 
    public function getType(): string
    {
        return $this->getDefinition()->getType();
    }
 
    public function reset(): void
    {
    }
 
 
    //
    // definition
    //
 
    abstract protected function isValidDefinition(ilADTDefinition $a_def): bool;
 
    protected function setDefinition(ilADTDefinition $a_def): void
    {
        if ($this->isValidDefinition($a_def)) {
            $this->definition = clone $a_def;
        } else {
            throw new ilException("ilADT invalid definition");
        }
    }
 
    protected function getDefinition(): ilADTDefinition
    {
        return $this->definition;
    }
 
    public function getCopyOfDefinition(): ilADTDefinition
    {
        return (clone $this->definition);
    }
 
 
    //
    // comparison
    //
 
    abstract public function equals(ilADT $a_adt): ?bool;
 
    abstract public function isLarger(ilADT $a_adt): ?bool;
 
    public function isLargerOrEqual(ilADT $a_adt): ?bool
    {
        if (!$this->getDefinition()->isComparableTo($a_adt)) {
            return null;
        }
        if ($this->equals($a_adt) === null || $this->isLarger($a_adt) === null) {
            return null;
        }
        return $this->equals($a_adt) || $this->isLarger($a_adt);
    }
 
    abstract public function isSmaller(ilADT $a_adt): ?bool;
 
    public function isSmallerOrEqual(ilADT $a_adt): ?bool
    {
        if (!$this->getDefinition()->isComparableTo($a_adt)) {
            return null;
        }
        if ($this->equals($a_adt) === null || $this->isSmaller($a_adt) === null) {
            return null;
        }
        return $this->equals($a_adt) || $this->isSmaller($a_adt);
    }
 
    public function isInbetween(ilADT $a_adt_from, ilADT $a_adt_to): ?bool
    {
        if (
            !$this->getDefinition()->isComparableTo($a_adt_from) ||
            !$this->getDefinition()->isComparableTo($a_adt_to)
        ) {
            return null;
        }
        if ($this->isLarger($a_adt_from) === null || $this->isSmaller($a_adt_to) === null) {
            return null;
        }
        return $this->isLarger($a_adt_from) && $this->isSmaller($a_adt_to);
    }
 
    public function isInbetweenOrEqual(ilADT $a_adt_from, ilADT $a_adt_to): ?bool
    {
        if (
            !$this->getDefinition()->isComparableTo($a_adt_from) ||
            !$this->getDefinition()->isComparableTo($a_adt_to)
        ) {
            return null;
        }
        if (
            $this->equals($a_adt_from) === null ||
            $this->equals($a_adt_to) === null ||
            $this->isInbetween($a_adt_from, $a_adt_to) === null
        ) {
            return null;
        }
        return
            $this->equals($a_adt_from) ||
            $this->equals($a_adt_to) ||
            $this->isInbetween($a_adt_from, $a_adt_to);
    }
 
    abstract public function isNull(): bool;
 
    public function isValid(): bool
    {
        $this->validation_errors = [];
 
        if (!$this->getDefinition()->isNullAllowed() && $this->isNull()) {
            $this->addValidationError(self::ADT_VALIDATION_ERROR_NULL_NOT_ALLOWED);
            return false;
        }
        return true;
    }
 
    protected function addValidationError(string $a_error_code): void
    {
        $this->validation_errors[] = $a_error_code;
    }
 
    public function getValidationErrors(): array
    {
        if (
            is_array($this->validation_errors) &&
            count($this->validation_errors)) {
            return array_unique($this->validation_errors);
        }
        return [];
    }
 
    public function translateErrorCode(string $a_code): string
    {
        switch ($a_code) {
            case self::ADT_VALIDATION_ERROR_NULL_NOT_ALLOWED:
                return $this->lng->txt("msg_input_is_required");
 
            case self::ADT_VALIDATION_ERROR_MAX_LENGTH:
                return $this->lng->txt("adt_error_max_length");
 
            case self::ADT_VALIDATION_ERROR_MAX_SIZE:
                return $this->lng->txt("adt_error_max_size");
 
            case self::ADT_VALIDATION_ERROR_MIN:
                return $this->lng->txt("form_msg_value_too_low");
 
            case self::ADT_VALIDATION_ERROR_MAX:
                return $this->lng->txt("form_msg_value_too_high");
 
                // :TODO: currently not used - see ilDateTimeInputGUI
            case self::ADT_VALIDATION_DATE:
                return $this->lng->txt("exc_date_not_valid");
        }
        throw new Exception("ADT unknown error code");
    }
 
    abstract public function getCheckSum(): ?string;
 
    abstract public function exportStdClass(): ?stdClass;
 
    abstract public function importStdClass(?stdClass $a_std): void;
}