class.ilCheckSumOfFileSizesJob.php

Go to the documentation of this file.

<?php
 
use ILIAS\BackgroundTasks\Observer;
use ILIAS\BackgroundTasks\Implementation\Tasks\AbstractJob;
use ILIAS\BackgroundTasks\Implementation\Values\ScalarValues\BooleanValue;
use ILIAS\BackgroundTasks\Types\SingleType;
use ILIAS\BackgroundTasks\Types\Type;
use ILIAS\BackgroundTasks\Value;
use ILIAS\components\File\Settings\General;
 
class ilCheckSumOfFileSizesJob extends AbstractJob
{
    private readonly ?ilLogger $logger;
    protected \ilSetting $settings;
 
 
    public function __construct()
    {
        global $DIC;
        $this->logger = $DIC->logger()->cal();
        $this->settings = new ilSetting("fold");
    }
 
 
    public function getInputTypes(): array
    {
        return
            [
                new SingleType(ilCopyDefinition::class),
            ];
    }
 
 
    public function getOutputType(): Type
    {
        return new SingleType(ilCopyDefinition::class);
    }
 
 
    public function isStateless(): bool
    {
        return true;
    }
 
 
    public function run(array $input, Observer $observer): Value
    {
        $this->logger->debug('Start checking adherence to maxsize!');
        $this->logger->dump($input);
        $definition = $input[0];
        $object_ref_ids = $definition->getObjectRefIds();
 
        // get global limit (max sum of individual file-sizes) from file settings
        $general = new General();
        $size_limit = $general->getDownloadLimitinMB();
        $size_limit_bytes = $size_limit * 1024 * 1024;
        $this->logger->debug('Global limit (max sum of all file-sizes) in file-settings: ' . $size_limit_bytes . ' bytes');
        // get sum of individual file-sizes
        $total_bytes = 0;
        $this->calculateRecursive($object_ref_ids, $total_bytes);
        $this->logger->debug('Calculated sum of all file-sizes: ' . $total_bytes . 'MB');
        // check if calculated total size adheres top global limit
        $adheres_to_limit = new BooleanValue();
        $adheres_to_limit->setValue(true);
        if ($total_bytes > $size_limit_bytes) {
            $adheres_to_limit->setValue(false);
        }
 
        $definition->setSumFileSizes($total_bytes);
        $definition->setAdheresToLimit($adheres_to_limit);
 
        return $definition;
    }
 
 
    protected function calculateRecursive(array $a_ref_ids, int &$a_file_size): void
    {
        global $DIC;
        $tree = $DIC['tree'];
 
        // parse folders
        foreach ($a_ref_ids as $ref_id) {
            if (!$this->validateAccess($ref_id)) {
                continue;
            }
 
            // we are only interested in folders and files
            switch (ilObject::_lookupType($ref_id, true)) {
                case "fold":
                    // get child objects
                    $subtree = $tree->getChildsByTypeFilter($ref_id, ["fold", "file"]);
                    if (count($subtree) > 0) {
                        $child_ref_ids = [];
                        foreach ($subtree as $child) {
                            $child_ref_ids[] = $child["ref_id"];
                        }
                        $this->calculateRecursive($child_ref_ids, $a_file_size);
                    }
                    break;
 
                case "file":
                    $a_file_size += ilObjFileAccess::_lookupFileSize($ref_id);
                    break;
            }
        }
    }
 
 
    protected function validateAccess(int $ref_id): bool
    {
        global $DIC;
        $ilAccess = $DIC['ilAccess'];
 
        if (!$ilAccess->checkAccess("read", "", $ref_id)) {
            return false;
        }
        return !ilObject::_isInTrash($ref_id);
    }
 
 
    public function getExpectedTimeOfTaskInSeconds(): int
    {
        return 30;
    }
}