class.ilTestArchiver.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

use ILIAS\UI\Factory as UIFactory;
use ILIAS\UI\Renderer as UIRenderer;
use ILIAS\Test\InternalRequestService;
use ILIAS\HTTP\GlobalHttpState;
use ILIAS\Refinery\Factory as RefineryFactory;

class ilTestArchiver
{
    #region Constants / Config

    public const DIR_SEP = '/';

    public const HTML_SUBMISSION_FILENAME = 'test_submission.html';
    public const PASS_MATERIALS_PATH_COMPONENT = 'materials';
    public const QUESTION_PATH_COMPONENT_PREFIX = 'q_';

    public const TEST_BEST_SOLUTION_PATH_COMPONENT = 'best_solution';
    public const HTML_BEST_SOLUTION_FILENAME = 'best_solution.html';
    public const TEST_MATERIALS_PATH_COMPONENT = 'materials';

    protected const TEST_RESULT_FILENAME = 'test_result.html';

    public const TEST_OVERVIEW_HTML_FILENAME = 'results_overview_html_v';
    public const TEST_OVERVIEW_HTML_POSTFIX = '.html';

    public const LOG_DTSGROUP_FORMAT = 'D M j G:i:s T Y';
    public const LOG_ADDITION_STRING = ' Adding ';
    public const LOG_CREATION_STRING = ' Creating ';
    public const LOG_UPDATE_STRING = ' Updating ';
    public const LOG_DELETION_STRING = ' Deleting ';

    public const TEST_LOG_FILENAME = 'test.log';
    public const DATA_INDEX_FILENAME = 'data_index.csv';
    public const ARCHIVE_LOG = 'archive.log';

    public const EXPORT_DIRECTORY = 'archive_exports';

    #endregion

    /*
     * Test-Archive Schema:
     *
     * <external directory>/<client>/tst_data/archive/tst_<obj_id>/
     *          - archive_data_index.dat
     *          - archive_log.log
     *
     *          - test_log.log
     *
     *          - test_results_v<n>.pdf
     *          - test_results_v<n>.csv
     *
     *          -> best_solution/
     *                  best_solution_v<n>.pdf
     *                  -> /materials/q_<question_fi>/<n>_<filename>
     *
     *          -> <year>/<month>/<day>/<ActiveFi>_<Pass>[_<Lastname>][_<Firstname>][_<Matriculation>]/
     *                  -> test_submission.pdf
     *                  -> test_submission.html
     *                  -> test_submission.sig (et al)
     *                  -> test_result_v<n>.pdf
     *                  -> /materials_v<n>/<question_fi>/<n>_<filename>
     */

    #region Properties

    protected $external_directory_path;
    protected $client_id;
    protected $test_obj_id;
    protected $test_ref_id;
    protected $archive_data_index;

    protected ilLanguage $lng;
    protected ilDBInterface $db;
    protected ilCtrl $ctrl;
    protected ilObjUser $user;
    protected ilTabsGUI $tabs;
    protected ilToolbarGUI $toolbar;
    protected ilGlobalTemplateInterface $tpl;
    protected UIFactory $ui_factory;
    protected UIRenderer $ui_renderer;
    protected ilAccess $access;
    protected InternalRequestService $testrequest;
    protected GlobalHttpState $http;
    protected RefineryFactory $refinery;

    protected ilTestHTMLGenerator $html_generator;

    protected $participantData;

    private \ILIAS\ResourceStorage\Services $irss;

    #endregion

    public function __construct(int $test_obj_id, ?int $test_ref_id = null)
    {
        global $DIC;
        $this->lng = $DIC['lng'];
        $this->db = $DIC['ilDB'];
        $this->ctrl = $DIC['ilCtrl'];
        $this->user = $DIC['ilUser'];
        $this->tabs = $DIC['ilTabs'];
        $this->toolbar = $DIC['ilToolbar'];
        $this->tpl = $DIC['tpl'];
        $this->ui_factory = $DIC['ui.factory'];
        $this->ui_renderer = $DIC['ui.renderer'];
        $this->access = $DIC['ilAccess'];
        $this->testrequest = $DIC->test()->internal()->request();
        $this->http = $DIC->http();
        $this->refinery = $DIC->refinery();
        $this->irss = $DIC->resourceStorage();

        $ilias = $DIC['ilias'];

        $this->html_generator = new ilTestHTMLGenerator();

        $this->external_directory_path = $ilias->ini_ilias->readVariable('clients', 'datadir');
        $this->client_id = $ilias->client_id;
        $this->test_obj_id = $test_obj_id;
        $this->test_ref_id = $test_ref_id;

        $this->archive_data_index = $this->readArchiveDataIndex();

        $this->participantData = null;
    }

    public function getParticipantData(): ?ilTestParticipantData
    {
        return $this->participantData;
    }

    public function setParticipantData($participantData)
    {
        $this->participantData = $participantData;
    }

    #region API methods

    public function handInParticipantQuestionMaterial($active_fi, $pass, $question_fi, $original_filename, $file_path)
    {
        $this->ensureTestArchiveIsAvailable();
        $this->ensurePassDataDirectoryIsAvailable($active_fi, $pass);

        $pass_question_directory = $this->getPassDataDirectory($active_fi, $pass)
            . self::DIR_SEP . self::QUESTION_PATH_COMPONENT_PREFIX . $question_fi;
        if (!is_dir($pass_question_directory)) {
            mkdir($pass_question_directory, 0777, true);
        }

        copy($file_path, $pass_question_directory . self::DIR_SEP . $original_filename);

        $this->logArchivingProcess(
            date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING
            . $pass_question_directory . self::DIR_SEP . $original_filename
        );
    }

    public function handInParticipantMisc($active_fi, $pass, $original_filename, $file_path)
    {
        $this->ensureTestArchiveIsAvailable();
        $this->ensurePassDataDirectoryIsAvailable($active_fi, $pass);
        $new_path = $this->getPassDataDirectory($active_fi, $pass) . self::DIR_SEP . $original_filename;
        copy($file_path, $new_path);
        $this->logArchivingProcess(date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $new_path);
    }

    public function handInTestBestSolution($best_solution)
    {
        $this->ensureTestArchiveIsAvailable();

        $best_solution_path = $this->getTestArchive() . self::DIR_SEP . self::TEST_BEST_SOLUTION_PATH_COMPONENT;
        if (!is_dir($best_solution_path)) {
            mkdir($best_solution_path, 0777, true);
        }

        $this->html_generator->generateHTML(
            $best_solution,
            $best_solution_path . self::DIR_SEP . self::HTML_BEST_SOLUTION_FILENAME
        );

        $this->logArchivingProcess(
            date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING
            . $best_solution_path . self::DIR_SEP . self::HTML_BEST_SOLUTION_FILENAME
        );

        $this->logArchivingProcess(
            date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $best_solution_path
        );
    }

    public function handInParticipantUploadedResults($active_fi, $pass, $tst_obj){
        $questions = $tst_obj->getQuestionsOfPass($active_fi, $pass);
        foreach ($questions as $question) {
            $question = $tst_obj->getQuestionDataset($question['question_fi']);
            if ($question->type_tag === 'assFileUpload') {
                $this->ensureTestArchiveIsAvailable();
                $this->ensurePassDataDirectoryIsAvailable($active_fi, $pass);
                $this->ensurePassMaterialsDirectoryIsAvailable($active_fi, $pass);
                $pass_material_directory = $this->getPassMaterialsDirectory($active_fi, $pass);
                $archive_folder = $pass_material_directory . self::DIR_SEP . $question->question_id . self::DIR_SEP;
                if (!file_exists($archive_folder)) {
                    mkdir($archive_folder, 0777, true);
                }
                // TODO old Filesystem remove on ILIAS 10
                $local_folder = CLIENT_WEB_DIR . '/assessment/tst_' . $tst_obj->test_id . self::DIR_SEP . $active_fi . self::DIR_SEP . $question->question_id . '/files/';
                if (file_exists($local_folder)) {
                    $folder_content = scandir($local_folder);
                    $folder_content = array_diff($folder_content, array('.', '..'));
                    foreach ($folder_content as $file_name) {
                        if (preg_match('/file_(\d+)_(\d+)_(\d+)/', $file_name, $matches)){
                            if ($active_fi == intval($matches[1]) && $pass == $matches[2]){
                                $local_file= $local_folder . $file_name;
                                $target_destination = $archive_folder . $file_name;
                                copy($local_file, $target_destination);
                                $this->logArchivingProcess(date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $target_destination);
                            }
                        }
                    }
                }
                // IRSS
                $resource_id = $tst_obj->getTextAnswer($active_fi, $question->question_id, $pass);
                if ($resource_id == ''){
                    continue;
                }
                $irss_unique_id = $this->irss->manage()->find($resource_id);
                if ($irss_unique_id != null){
                    $resource = $this->irss->manage()->getResource($irss_unique_id);
                    $information = $resource->getCurrentRevision()->getInformation();
                    $stream = $this->irss->consume()->stream($irss_unique_id);
                    // this feels unnecessary..
                    $file_stream = fopen($stream->getStream()->getMetadata('uri'), 'r');
                    $file_content = stream_get_contents($file_stream);
                    fclose($file_stream);
                    $target_destination = $archive_folder . $information->getTitle();
                    file_put_contents($target_destination, $file_content);
                }
            }
        }
    }

    public function handInBestSolutionQuestionMaterial($question_fi, $orginial_filename, $file_path)
    {
        $this->ensureTestArchiveIsAvailable();

        $best_solution_path = $this->getTestArchive() . self::DIR_SEP . self::TEST_BEST_SOLUTION_PATH_COMPONENT;
        if (!is_dir($best_solution_path)) {
            mkdir($best_solution_path, 0777, true);
        }

        $materials_path = $best_solution_path . self::DIR_SEP . self::TEST_MATERIALS_PATH_COMPONENT;
        if (!is_dir($materials_path)) {
            mkdir($materials_path, 0777, true);
        }

        $question_materials_path = $materials_path . self::DIR_SEP . self::QUESTION_PATH_COMPONENT_PREFIX . $question_fi;
        if (!is_dir($question_materials_path)) {
            mkdir($question_materials_path, 0777, true);
        }

        copy($file_path, $question_materials_path . self::DIR_SEP . $orginial_filename);

        $this->logArchivingProcess(
            date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING
            . $question_materials_path . self::DIR_SEP . $orginial_filename
        );
    }

    public function handInTestResult($active_fi, $pass, $pdf_path)
    {
        $this->ensureTestArchiveIsAvailable();
        $this->ensurePassDataDirectoryIsAvailable($active_fi, $pass);
        $new_path = $this->getPassDataDirectory($active_fi, $pass) . self::DIR_SEP . self::TEST_RESULT_FILENAME;
        copy($pdf_path, $new_path);
        $this->logArchivingProcess(date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $new_path);
    }

    #endregion

    #region TestArchive
    // The TestArchive lives here: <external directory>/<client>/tst_data/archive/tst_<obj_id>/

    protected function hasTestArchive(): bool
    {
        return is_dir($this->getTestArchive());
    }

    protected function createArchiveForTest()
    {
        ilFileUtils::makeDirParents($this->getTestArchive());
        //mkdir( $this->getTestArchive(), 0777, true );
    }

    protected function getTestArchive(): string
    {
        $test_archive_directory = $this->external_directory_path . self::DIR_SEP . $this->client_id . self::DIR_SEP . 'tst_data'
            . self::DIR_SEP . 'archive' . self::DIR_SEP . 'tst_' . $this->test_obj_id;
        return $test_archive_directory;
    }

    protected function ensureTestArchiveIsAvailable()
    {
        if (!$this->hasTestArchive()) {
            $this->createArchiveForTest();
        }
        return;
    }

    public function updateTestArchive()
    {
        $query = 'SELECT * FROM ass_log WHERE obj_fi = ' . $this->db->quote($this->test_obj_id, 'integer');
        $result = $this->db->query($query);

        $outfile_lines = '';
        while ($row = $this->db->fetchAssoc($result)) {
            $outfile_lines .= "\r\n" . implode("\t", $row);
        }
        file_put_contents($this->getTestArchive() . self::DIR_SEP . self::TEST_LOG_FILENAME, $outfile_lines);

        // Generate test pass overview
        $test = new ilObjTest($this->test_obj_id, false);
        if ($this->test_ref_id !== null) {
            $test->setRefId($this->test_ref_id);
        }

        $gui = new ilParticipantsTestResultsGUI(
            $this->ctrl,
            $this->lng,
            $this->db,
            $this->user,
            $this->tabs,
            $this->toolbar,
            $this->tpl,
            $this->ui_factory,
            $this->ui_renderer,
            new ilTestParticipantAccessFilterFactory($this->access),
            $this->testrequest,
            $this->http,
            $this->refinery
        );
        $gui->setTestObj($test);

        $objectiveOrientedContainer = new ilTestObjectiveOrientedContainer();
        $gui->setObjectiveParent($objectiveOrientedContainer);
        $array_of_actives = array();
        $participants = $test->getParticipants();

        foreach ($participants as $key => $value) {
            $array_of_actives[] = $key;
        }
        $output_template = $gui->createUserResults(true, false, true, $array_of_actives);

        $filename = realpath($this->getTestArchive()) . self::DIR_SEP . 'participant_pass_overview.html';
        $this->html_generator->generateHTML($output_template->get(), $filename);

        return;
    }

    public function ensureZipExportDirectoryExists()
    {
        if (!$this->hasZipExportDirectory()) {
            $this->createZipExportDirectory();
        }
    }

    public function hasZipExportDirectory(): bool
    {
        return is_dir($this->getZipExportDirectory());
    }

    protected function createZipExportDirectory()
    {
        mkdir($this->getZipExportDirectory(), 0777, true);
    }

    public function getZipExportDirectory(): string
    {
        return $this->external_directory_path . self::DIR_SEP . $this->client_id . self::DIR_SEP . 'tst_data'
            . self::DIR_SEP . self::EXPORT_DIRECTORY . self::DIR_SEP . 'tst_' . $this->test_obj_id;
    }

    public function compressTestArchive()
    {
        $this->updateTestArchive();
        $this->ensureZipExportDirectoryExists();

        $zip_output_path = $this->getZipExportDirectory();
        $zip_output_filename = 'test_archive_obj_' . $this->test_obj_id . '_' . time() . '_.zip';

        ilFileUtils::zip($this->getTestArchive(), $zip_output_path . self::DIR_SEP . $zip_output_filename, true);
        return;
    }

    #endregion

    #region PassDataDirectory
    // The pass data directory contains all data relevant for a participants pass.
    // In addition to the test-archive-directory, this directory lives here:
    // .../<year>/<month>/<day>/<ActiveFi>_<Pass>[_<Lastname>][_<Firstname>][_<Matriculation>]/
    // Lastname, Firstname and Matriculation are not mandatory in the directory name.

    protected function hasPassDataDirectory($active_fi, $pass): bool
    {
        $pass_data_dir = $this->getPassDataDirectory($active_fi, $pass);
        return is_dir($this->getPassDataDirectory($active_fi, $pass));
    }

    protected function createPassDataDirectory($active_fi, $pass)
    {
        mkdir($this->getPassDataDirectory($active_fi, $pass), 0777, true);
        return;
    }

    private function buildPassDataDirectory($active_fi, $pass): ?string
    {
        foreach ($this->archive_data_index as $data_index_entry) {
            if ($data_index_entry != null && $data_index_entry['identifier'] == $active_fi . '|' . $pass) {
                array_shift($data_index_entry);
                return $this->getTestArchive() . self::DIR_SEP . implode(self::DIR_SEP, $data_index_entry);
            }
        }

        return null;
    }

    protected function getPassDataDirectory($active_fi, $pass): ?string
    {
        $pass_data_dir = $this->buildPassDataDirectory($active_fi, $pass);

        if ($pass_data_dir !== null) {
            return $pass_data_dir;
        }

        $test_obj = new ilObjTest($this->test_obj_id, false);
        if ($test_obj->getAnonymity()) {
            $firstname = 'anonym';
            $lastname = '';
            $matriculation = '0';
        } else {
            if ($this->getParticipantData()) {
                $usr_data = $this->getParticipantData()->getUserDataByActiveId($active_fi);
                $firstname = $usr_data['firstname'];
                $lastname = $usr_data['lastname'];
                $matriculation = $usr_data['matriculation'];
            } else {

                $firstname = $this->user->getFirstname();
                $lastname = $this->user->getLastname();
                $matriculation = $this->user->getMatriculation();
            }
        }

        $this->appendToArchiveDataIndex(
            date(DATE_ISO8601),
            $active_fi,
            $pass,
            $firstname,
            $lastname,
            $matriculation
        );

        return $this->buildPassDataDirectory($active_fi, $pass);
    }

    protected function ensurePassDataDirectoryIsAvailable($active_fi, $pass)
    {
        if (!$this->hasPassDataDirectory($active_fi, $pass)) {
            $this->createPassDataDirectory($active_fi, $pass);
        }
        return;
    }

    #endregion

    #region PassMaterialsDirectory

    protected function hasPassMaterialsDirectory($active_fi, $pass): bool
    {
        if (@is_dir($this->getPassMaterialsDirectory($active_fi, $pass))) {
            return true;
        }
        return false;
    }

    protected function createPassMaterialsDirectory($active_fi, $pass): string
    {
        // Data are taken from the current user as the implementation expects the first interaction of the pass
        // takes place from the usage/behaviour of the current user.

        $user = $this->user;

        if ($this->getParticipantData()) {
            $usrData = $this->getParticipantData()->getUserDataByActiveId($active_fi);
            $user = new ilObjUser();
            $user->setFirstname($usrData['firstname']);
            $user->setLastname($usrData['lastname']);
            $user->setMatriculation($usrData['matriculation']);
            $user->setFirstname($usrData['firstname']);
        }

        $this->appendToArchiveDataIndex(
            date('c'),
            $active_fi,
            $pass,
            $user->getFirstname(),
            $user->getLastname(),
            $user->getMatriculation()
        );
        $material_directory = $this->getPassMaterialsDirectory($active_fi, $pass);
        mkdir($material_directory, 0777, true);
        return $material_directory;
    }

    protected function getPassMaterialsDirectory($active_fi, $pass): string
    {
        $pass_data_directory = $this->getPassDataDirectory($active_fi, $pass);
        return $pass_data_directory . self::DIR_SEP . self::PASS_MATERIALS_PATH_COMPONENT;
    }

    protected function ensurePassMaterialsDirectoryIsAvailable($active_fi, $pass)
    {
        if (!$this->hasPassMaterialsDirectory($active_fi, $pass)) {
            $this->createPassMaterialsDirectory($active_fi, $pass);
        }
    }

    #endregion

    protected function readArchiveDataIndex(): array
    {
        $data_index_file = $this->getTestArchive() . self::DIR_SEP . self::DATA_INDEX_FILENAME;

        $contents = array();

        if (@file_exists($data_index_file)) {
            $lines = explode("\n", file_get_contents($data_index_file));
            foreach ($lines as $line) {
                if (strlen($line) === 0) {
                    continue;
                }
                $line_items = explode('|', $line);
                $line_data = [];
                $line_data['identifier'] = $line_items[0] . '|' . $line_items[1];
                $line_data['yyyy'] = $line_items[2];
                $line_data['mm'] = $line_items[3];
                $line_data['dd'] = $line_items[4];
                $line_data['directory'] = $line_items[5];
                $contents[] = $line_data;
            }
        }
        return $contents;
    }

    protected function appendToArchiveDataIndex($date, $active_fi, $pass, $user_firstname, $user_lastname, $matriculation)
    {
        $line = $this->determinePassDataPath($date, $active_fi, $pass, $user_firstname, $user_lastname, $matriculation);

        $this->archive_data_index[] = $line;
        $output_contents = '';

        foreach ($this->archive_data_index as $line_data) {
            if ($line_data['identifier'] == "|") {
                continue;
            }
            $output_contents .= implode('|', $line_data) . "\n";
        }

        file_put_contents($this->getTestArchive() . self::DIR_SEP . self::DATA_INDEX_FILENAME, $output_contents);
        $this->readArchiveDataIndex();
        return;
    }

    protected function determinePassDataPath($date, $active_fi, $pass, $user_firstname, $user_lastname, $matriculation): array
    {
        $date = date_create_from_format('Y-m-d\TH:i:sP', $date);
        if (!$date) {
            throw new Exception('Invalid date format. Expected ISO 8601 format.');
        }

        $line = array(
            'identifier' => $active_fi . '|' . $pass,
            'yyyy' => date_format($date, 'Y'),
            'mm' => date_format($date, 'm'),
            'dd' => date_format($date, 'd'),
            'directory' => $active_fi . '_' . $pass . '_' . $user_firstname . '_' . $user_lastname . '_' . $matriculation
        );
        return $line;
    }

    protected function logArchivingProcess($message)
    {
        $archive = $this->getTestArchive() . self::DIR_SEP . self::ARCHIVE_LOG;
        if (file_exists($archive)) {
            $content = file_get_contents($archive) . "\n" . $message;
        } else {
            $content = $message;
        }

        file_put_contents($archive, $content);
    }

    protected function countFilesInDirectory($directory, $pattern = null): int
    {
        $filecount = 0;

        if ($handle = opendir($directory)) {
            while (($file = readdir($handle)) !== false) {
                if (!in_array($file, array( '.', '..' )) && !is_dir($directory . $file)) {
                    if ($pattern && strpos($file, $pattern) === 0) {
                        $filecount++;
                    }
                }
            }
        }
        return $filecount;
    }
}