class.ilAssOrderingElement.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\TestQuestionPool\ExportImport\Normalize\Envelopes\QuestionImage;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\FromNormalized;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\ToNormalized;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Transformations;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Envelopes\Id;
 
class ilAssOrderingElement implements ToNormalized, FromNormalized
{
    public const EXPORT_IDENT_PROPERTY_SEPARATOR = '_';
 
    public static $objectInstanceCounter = 0;
    public $objectInstanceId;
 
    public int $id;
 
    protected ?int $random_identifier = null;
 
    protected ?int $solution_identifier = null;
 
    protected int $indentation = 0;
 
    protected ?int $position = null;
    protected ?string $content = null;
    protected ?string $uploadImageName = null;
    protected ?string $uploadImageFile = null;
    protected bool $imageRemovalRequest = false;
    protected ?string $imagePathWeb = null;
    protected ?string $image_path_fs = null;
    protected $imageThumbnailPrefix = null;
 
    public function __construct(int $id = -1)
    {
        $this->id = $id;
        $this->objectInstanceId = ++self::$objectInstanceCounter;
    }
 
    public function __clone()
    {
        $this->objectInstanceId = ++self::$objectInstanceCounter;
    }
 
    public function getClone(): ilAssOrderingElement
    {
        return clone $this;
    }
 
    public function getId(): int
    {
        return $this->id;
    }
 
    public function setId(int $id): void
    {
        $this->id = $id;
    }
 
    public function getRandomIdentifier(): ?int
    {
        return $this->random_identifier;
    }
 
    public function setRandomIdentifier(int $random_identifier): void
    {
        $this->random_identifier = $random_identifier;
    }
 
    public function getSolutionIdentifier(): ?int
    {
        return $this->solution_identifier;
    }
 
    public function setSolutionIdentifier(int $solution_identifier): void
    {
        $this->solution_identifier = $solution_identifier;
    }
 
    public function setIndentation(int $indentation): void
    {
        $this->indentation = $indentation;
    }
 
    public function getIndentation(): int
    {
        return $this->indentation;
    }
 
    public function getPosition(): ?int
    {
        return $this->position;
    }
 
    public function setPosition(int $position): void
    {
        $this->position = $position;
    }
 
    public function getContent(): ?string
    {
        return $this->content;
    }
 
 
    public function setContent($content): void
    {
        if (is_array($content)) {
            $content = array_shift($content);
        }
        $this->content = $content;
    }
 
    public function getUploadImageFile(): ?string
    {
        return $this->uploadImageFile;
    }
 
    public function setUploadImageFile($uploadImageFile): void
    {
        if (is_array($uploadImageFile)) {
            $uploadImageFile = array_shift($uploadImageFile);
        }
        $this->uploadImageFile = $uploadImageFile;
    }
 
    public function getUploadImageName(): ?string
    {
        return $this->uploadImageName;
    }
 
    public function setUploadImageName($uploadImageName): void
    {
        if (is_array($uploadImageName)) {
            $uploadImageName = array_shift($uploadImageName);
        }
        $this->uploadImageName = $uploadImageName;
    }
 
    public function isImageUploadAvailable(): bool
    {
        return $this->getUploadImageFile() !== null
            && $this->getUploadImageFile() !== '';
    }
 
    public function isImageRemovalRequest(): ?bool
    {
        return $this->imageRemovalRequest;
    }
 
    public function setImageRemovalRequest($imageRemovalRequest): void
    {
        $this->imageRemovalRequest = $imageRemovalRequest;
    }
 
    public function getImagePathWeb(): ?string
    {
        return $this->imagePathWeb;
    }
 
    public function setImagePathWeb($imagePathWeb): void
    {
        $this->imagePathWeb = $imagePathWeb;
    }
 
    public function getImagePathFs(): ?string
    {
        return $this->image_path_fs;
    }
 
    public function setImagePathFs(string $image_path_fs): void
    {
        $this->image_path_fs = $image_path_fs;
    }
 
    public function getImageThumbnailPrefix()
    {
        return $this->imageThumbnailPrefix;
    }
 
    public function setImageThumbnailPrefix($imageThumbnailPrefix): void
    {
        $this->imageThumbnailPrefix = $imageThumbnailPrefix;
    }
 
    public function isSameElement(ilAssOrderingElement $element): bool
    {
        return [
            $this->getRandomIdentifier(),
            $this->getSolutionIdentifier(),
            $this->getPosition(),
            $this->getIndentation(),
        ] == [
            $element->getRandomIdentifier(),
            $element->getSolutionIdentifier(),
            $element->getPosition(),
            $element->getIndentation()
        ];
    }
 
    public function getStorageValue1(int $ordering_type): int|string
    {
        switch ($ordering_type) {
            case assOrderingQuestion::OQ_NESTED_TERMS:
            case assOrderingQuestion::OQ_NESTED_PICTURES:
 
                return $this->getPosition();
 
            case assOrderingQuestion::OQ_TERMS:
            case assOrderingQuestion::OQ_PICTURES:
            default:
                return $this->getSolutionIdentifier();
        }
    }
 
    public function getStorageValue2(int $ordering_type): int|string
    {
        switch ($ordering_type) {
            case assOrderingQuestion::OQ_NESTED_TERMS:
            case assOrderingQuestion::OQ_NESTED_PICTURES:
 
                return $this->getRandomIdentifier() . ':' . $this->getIndentation();
 
            case assOrderingQuestion::OQ_TERMS:
            case assOrderingQuestion::OQ_PICTURES:
            default:
                return $this->getPosition() + 1;
        }
    }
 
    public function __toString(): string
    {
        return $this->getContent() ?? '';
    }
 
    protected function thumbnailFileExists(): bool
    {
        if (!$this->getContent()) {
            return false;
        }
 
        return file_exists($this->getThumbnailFilePath());
    }
 
    protected function getThumbnailFilePath(): string
    {
        return $this->getImagePathFs() . $this->getImageThumbnailPrefix() . $this->getContent();
    }
 
    protected function getThumbnailFileUrl(): string
    {
        return $this->getImagePathWeb() . $this->getImageThumbnailPrefix() . $this->getContent();
    }
 
    protected function imageFileExists(): bool
    {
        if (!$this->getContent()) {
            return false;
        }
 
        return file_exists($this->getImageFilePath());
    }
 
    protected function getImageFilePath(): string
    {
        return $this->getImagePathFs() . $this->getContent();
    }
 
    protected function getImageFileUrl(): string
    {
        return $this->getImagePathWeb() . $this->getContent();
    }
 
    public function getPresentationImageUrl(): string
    {
        if ($this->thumbnailFileExists()) {
            return $this->getThumbnailFileUrl();
        }
 
        if ($this->imageFileExists()) {
            return $this->getImageFileUrl();
        }
 
        return '';
    }
 
    public function getExportIdent(): string
    {
        $ident = [
            $this->getRandomIdentifier(),
            $this->getSolutionIdentifier(),
            $this->getPosition(),
            $this->getIndentation()
        ];
 
        return implode(self::EXPORT_IDENT_PROPERTY_SEPARATOR, $ident);
    }
 
    public function isExportIdent(string $ident): bool
    {
        if (!strlen($ident)) {
            return false;
        }
 
        $parts = explode(self::EXPORT_IDENT_PROPERTY_SEPARATOR, $ident);
        return
            count($parts) == 4
            && ilAssOrderingElementList::isValidRandomIdentifier($parts[0])
            && ilAssOrderingElementList::isValidSolutionIdentifier($parts[1])
            && ilAssOrderingElementList::isValidPosition($parts[2])
            && ilAssOrderingElementList::isValidIndentation($parts[3]);
    }
 
    public function setExportIdent($ident): void
    {
        if ($this->isExportIdent($ident)) {
            list($randomId, $solutionId, $pos, $indent) = explode(
                self::EXPORT_IDENT_PROPERTY_SEPARATOR,
                $ident
            );
            $this->setRandomIdentifier((int) $randomId);
            $this->setSolutionIdentifier((int) $solutionId);
            $this->setPosition((int) $pos);
            $this->setIndentation((int) $indent);
        }
    }
 
 
    public function withRandomIdentifier(int $id): self
    {
        $clone = clone $this;
        $clone->random_identifier = $id;
        return $clone;
    }
    public function withSolutionIdentifier(int $id): self
    {
        $clone = clone $this;
        $clone->solution_identifier = $id;
        return $clone;
    }
    public function withPosition(int $position): self
    {
        $clone = clone $this;
        $clone->position = $position;
        return $clone;
    }
    public function withIndentation(int $indentation): self
    {
        $clone = clone $this;
        $clone->indentation = $indentation;
        return $clone;
    }
    public function withContent(string $content): self
    {
        $clone = clone $this;
        $clone->content = $content;
        return $clone;
    }
 
    #[\Override]
    public function toNormalized(Transformations $transformations, array $context = []): array|float|bool|int|string|null
    {
        return [
            'id' => $transformations->normalize(new Id($this->id, 'ordering')),
            'random_identifier' => $this->random_identifier,
            'solution_identifier' => $this->solution_identifier,
            'position' => $this->position,
            'indentation' => $this->indentation,
            'content' => $this->content ? $transformations->normalize(
                new QuestionImage($this->content, $context['question_id'] ?? null)
            ) : null,
        ];
    }
 
    #[\Override]
    public function fromNormalized(array $normalized, Transformations $transformations): self
    {
        $clone = $this->withRandomIdentifier($transformations->int($normalized['random_identifier']))
                    ->withSolutionIdentifier($transformations->int($normalized['solution_identifier']))
                    ->withPosition($transformations->int($normalized['position']))
                    ->withIndentation($transformations->int($normalized['indentation']));
 
        if (is_array($normalized['content'])) {
            $clone->setContent($transformations->denormalize($normalized['content'], QuestionImage::class)?->getFilename());
        } else {
            $clone->setContent((string) $normalized['content']);
        }
 
        $clone->setId($transformations->denormalize($normalized['id'], Id::class)->getId());
 
        return $clone;
    }
}