class.ilTestArchiver.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilTestArchiver 
{
        #region Constants / Config
 
        const DIR_SEP                                                           = '/';
 
        const HTML_SUBMISSION_FILENAME                          = 'test_submission.html';
        const PDF_SUBMISSION_FILENAME                           = 'test_submission.pdf';
        const PASS_MATERIALS_PATH_COMPONENT                     = 'materials';
        const QUESTION_PATH_COMPONENT_PREFIX            = 'q_';
 
        const TEST_BEST_SOLUTION_PATH_COMPONENT         = 'best_solution';
        const HTML_BEST_SOLUTION_FILENAME                       = 'best_solution.html';
        const PDF_BEST_SOLUTION_FILENAME                        = 'best_solution.pdf';
        const TEST_MATERIALS_PATH_COMPONENT                     = 'materials';
 
        const TEST_RESULT_FILENAME                                      = 'test_result_v';
        const TEST_RESULT_POSTFIX                                       = '.pdf';
 
        const TEST_OVERVIEW_PDF_FILENAME                        = 'results_overview_html_v';
        const TEST_OVERVIEW_PDF_POSTFIX                         = '.pdf';
 
        const TEST_OVERVIEW_HTML_FILENAME                       = 'results_overview_pdf_v';
        const TEST_OVERVIEW_HTML_POSTFIX                        = '.html';
 
        const LOG_DTSGROUP_FORMAT                                       = 'D M j G:i:s T Y';
        const LOG_ADDITION_STRING                                       = ' Adding ';
        const LOG_CREATION_STRING                                       = ' Creating ';
        const LOG_UPDATE_STRING                                         = ' Updating ';
        const LOG_DELETION_STRING                                       = ' Deleting ';
 
        const TEST_LOG_FILENAME                                         = 'test.log';
        const DATA_INDEX_FILENAME                                       = 'data_index.csv';
        const ARCHIVE_LOG                                                       = 'archive.log';
 
        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 $archive_data_index;          
        protected $ilDB;                                        
        protected $participantData;
 
        #endregion
 
        public function __construct($test_obj_id)
        {
                global $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->ilDB                                             = $ilias->db;
 
                $this->archive_data_index               = $this->readArchiveDataIndex();
                
                $this->participantData = null;
        }
        
        public function getParticipantData()
        {
                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 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 . ($this->countFilesInDirectory( $this->getPassDataDirectory($active_fi, $pass), self::TEST_RESULT_FILENAME ))
                        . self::TEST_RESULT_POSTFIX;
                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() 
        {
                return is_dir($this->getTestArchive());
        }
 
        protected function createArchiveForTest() 
        {
                ilUtil::makeDirParents($this->getTestArchive());
                //mkdir( $this->getTestArchive(), 0777, true );
        }
 
        protected function getTestArchive() 
        {
                $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);
                $gui = new ilObjTestGUI();
                $gui->object = $test;
                $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);
 
                require_once 'class.ilTestPDFGenerator.php';
                $filename = realpath($this->getTestArchive()) . self::DIR_SEP . 'participant_pass_overview.pdf';
                ilTestPDFGenerator::generatePDF($output_template->get(), ilTestPDFGenerator::PDF_OUTPUT_FILE, $filename);
                
                return;
        }
 
        public function ensureZipExportDirectoryExists()
        {
                if (!$this->hasZipExportDirectory())
                {
                        $this->createZipExportDirectory();
                }
        }
 
        public function hasZipExportDirectory()
        {
                return is_dir($this->getZipExportDirectory());
        }
 
        protected function createZipExportDirectory()
        {
                mkdir($this->getZipExportDirectory(), 0777, true);
        }
 
        public function getZipExportDirectory()
        {
                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';
                
                ilUtil::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) 
        {
                $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)
        {
                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) 
        {
                $passDataDir = $this->buildPassDataDirectory($active_fi, $pass);
                
                if( !$passDataDir )
                {
                        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 $ilUser;
                                $user = $ilUser;
                        }
                        
                        $this->appendToArchiveDataIndex(
                                date(DATE_ISO8601), $active_fi, $pass,
                                $user->getFirstname(), $user->getLastname(), $user->getMatriculation()
                        );
                        
                        $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)
        {
                if ( @is_dir( $this->getPassMaterialsDirectory($active_fi, $pass)) )
                {
                        return true;
                }
                return false;
        }
 
        protected function createPassMaterialsDirectory($active_fi, $pass)
        {
                // 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 $ilUser;
                        $user = $ilUser;
                }
 
                $this->appendToArchiveDataIndex(
                        date('Y'), $active_fi, $pass, $user->getFirstname(), $user->getLastname(), $user->getMatriculation()
                );
                mkdir($this->getPassMaterialsDirectory($active_fi, $pass) , 0777, true );
        }
 
        protected function getPassMaterialsDirectory($active_fi, $pass)
        {
                $pass_data_directory = $this->getPassMaterialsDirectory($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() 
        {
                $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)
                        {
                                $line_items = explode('|', $line);
                                $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)
        {
                $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)
        {
                $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;
        }
}