class.ilTestArchiver.php

Go to the documentation of this file.

<?php
 
class ilTestArchiver
{
    #region Constants / Config
 
    public const DIR_SEP = '/';
 
    public const HTML_SUBMISSION_FILENAME = 'test_submission.html';
    public const PDF_SUBMISSION_FILENAME = 'test_submission.pdf';
    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 PDF_BEST_SOLUTION_FILENAME = 'best_solution.pdf';
    public const TEST_MATERIALS_PATH_COMPONENT = 'materials';
 
    protected const TEST_RESULT_FILENAME = 'test_result.pdf';
 
    public const TEST_OVERVIEW_PDF_FILENAME = 'results_overview_html_v';
    public const TEST_OVERVIEW_PDF_POSTFIX = '.pdf';
 
    public const TEST_OVERVIEW_HTML_FILENAME = 'results_overview_pdf_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 ilDBInterface $ilDB;
 
    protected $participantData;
 
    #endregion
 
    public function __construct($test_obj_id, $test_ref_id = null)
    {
        global $DIC;
        $ilias = $DIC['ilias'];
        $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->ilDB = $ilias->db;
 
        $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 handInParticipantSubmission($active_fi, $pass, $pdf_path, $html_string)
    {
        $this->ensureTestArchiveIsAvailable();
        $this->ensurePassDataDirectoryIsAvailable($active_fi, $pass);
 
        $pdf_new_path = $this->getPassDataDirectory($active_fi, $pass) . self::DIR_SEP
            . self::PDF_SUBMISSION_FILENAME;
        copy($pdf_path, $pdf_new_path);
        # /home/mbecker/public_html/ilias/trunk-primary/extern/default/tst_data/archive/tst_350/2013/09/19/80_1_root_user_/test_submission.pdf
        $html_new_path = $this->getPassDataDirectory($active_fi, $pass) . self::DIR_SEP
            . self::HTML_SUBMISSION_FILENAME;
        file_put_contents($html_new_path, $html_string);
 
        $this->logArchivingProcess(date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $pdf_new_path);
        $this->logArchivingProcess(date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $html_new_path);
    }
 
    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 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') {
                $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)) {
                    continue; // no file submissions
                }
                $this->ensureTestArchiveIsAvailable();
                $this->ensurePassDataDirectoryIsAvailable($active_fi, $pass);
                $folder_content = scandir($local_folder);
                $folder_content = array_diff($folder_content, array('.', '..'));
                $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);
                }
                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);
                        }
                    }
                }
            }
        }
    }
 
    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($html_string, $pdf_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);
        }
 
        file_put_contents($best_solution_path . self::DIR_SEP . self::HTML_BEST_SOLUTION_FILENAME, $html_string);
 
        copy($pdf_path, $best_solution_path . self::DIR_SEP . self::PDF_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 . self::DIR_SEP . self::PDF_BEST_SOLUTION_FILENAME
        );
    }
 
    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);
    }
 
    public function handInTestResultsOverview($html_string, $pdf_path)
    {
        $this->ensureTestArchiveIsAvailable();
        $new_pdf_path = $this->getTestArchive() . self::DIR_SEP
            . self::TEST_OVERVIEW_PDF_FILENAME
            . $this->countFilesInDirectory($this->getTestArchive(), self::TEST_OVERVIEW_PDF_FILENAME) . self::TEST_OVERVIEW_PDF_POSTFIX;
        copy($pdf_path, $new_pdf_path);
        $html_path = $this->getTestArchive() . self::DIR_SEP . self::TEST_OVERVIEW_HTML_FILENAME
            . $this->countFilesInDirectory($this->getTestArchive(), self::TEST_OVERVIEW_HTML_FILENAME) . self::TEST_OVERVIEW_HTML_POSTFIX;
        file_put_contents($html_path, $html_string);
 
        $this->logArchivingProcess(date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $new_pdf_path);
        $this->logArchivingProcess(date(self::LOG_DTSGROUP_FORMAT) . self::LOG_ADDITION_STRING . $html_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->ilDB->quote($this->test_obj_id, 'integer');
        $result = $this->ilDB->query($query);
 
        $outfile_lines = '';
        while ($row = $this->ilDB->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();
        $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.pdf';
        ilTestPDFGenerator::generatePDF($output_template->get(), ilTestPDFGenerator::PDF_OUTPUT_FILE, $filename, PDF_USER_RESULT);
 
        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
    {
        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
    {
        $passDataDir = $this->buildPassDataDirectory($active_fi, $pass);
 
        if (!$passDataDir) {
            $test_obj = new ilObjTest($this->test_obj_id, false);
            if ($test_obj->getAnonymity()) {
                $firstname = 'anonym';
                $lastname = '';
                $matriculation = '0';
            } else {
                if ($this->getParticipantData()) {
                    $usrData = $this->getParticipantData()->getUserDataByActiveId($active_fi);
                    $firstname = $usrData['firstname'];
                    $lastname = $usrData['lastname'];
                    $matriculation = $usrData['matriculation'];
                } else {
                    global $DIC;
                    $ilUser = $DIC['ilUser'];
                    $firstname = $ilUser->getFirstname();
                    $lastname = $ilUser->getLastname();
                    $matriculation = $ilUser->getMatriculation();
                }
            }
 
            $this->appendToArchiveDataIndex(
                date(DATE_ISO8601),
                $active_fi,
                $pass,
                $firstname,
                $lastname,
                $matriculation
            );
 
            $passDataDir = $this->buildPassDataDirectory($active_fi, $pass);
        }
 
        return $passDataDir;
    }
 
    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.
 
        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']);
        } else {
            global $DIC;
            $ilUser = $DIC['ilUser'];
            $user = $ilUser;
        }
 
        $this->appendToArchiveDataIndex(
            date(DATE_ISO8601),
            $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(DATE_ISO8601, $date);
        $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;
    }
}