class.ilObjBibliographic.php

Go to the documentation of this file.

<?php
 
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilObjBibliographic extends ilObject2
{
 
    protected $bib_filereader_factory;
    protected $bib_type_factory;
    protected $bib_entry_factory;
    protected $bib_field_factory;
    protected $bib_data_factory;
    protected $bib_overview_factory;
    protected $bib_attribute_factory;
    protected $filename;
    protected $entries;
    protected $is_online;
    protected $file_type = 0;
 
 
    public function initType()
    {
        $this->type = "bibl";
    }
 
 
    public function __construct($existant_bibl_id = 0)
    {
        if ($existant_bibl_id) {
            $this->setId($existant_bibl_id);
            $this->doRead();
        }
        parent::__construct($existant_bibl_id, false);
 
        $this->bib_type_factory = new ilBiblTypeFactory();
        $this->bib_field_factory = new ilBiblFieldFactory($this->bib_type_factory->getInstanceForType($this->getFileType()));
        $this->bib_overview_factory = new ilBiblOverviewModelFactory();
        $this->bib_entry_factory = new ilBiblEntryFactory($this->bib_field_factory, $this->bib_type_factory->getInstanceForType($this->getFileType()), $this->bib_overview_factory);
        $this->bib_filereader_factory = new ilBiblFileReaderFactory();
        $this->bib_attribute_factory = new ilBiblAttributeFactory($this->bib_field_factory);
    }
 
 
    protected function doCreate()
    {
        global $DIC;
 
        $upload = $DIC->upload();
        if ($upload->hasUploads() && !$upload->hasBeenProcessed()) {
            $upload->process();
            $this->moveUploadedFile($upload);
        }
 
        $DIC->database()->insert(
            "il_bibl_data",
            [
                "id" => ["integer", $this->getId()],
                "filename" => ["text", $this->getFilename()],
                "is_online" => ["integer", $this->getOnline()],
                "file_type" => ["integer", $this->getFilename() ? $this->determineFileTypeByFileName($this->getFilename()) : ""],
            ]
        );
    }
 
 
    protected function doRead()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $ilBiblData = ilBiblData::where(array('id' => $this->getId()))->first();
        if (!$this->getFilename()) {
            $this->setFilename($ilBiblData->getFilename());
        }
        $this->setFileType($ilBiblData->getFileType());
        $this->setOnline($ilBiblData->getIsOnline());
    }
 
 
    public function doUpdate()
    {
        global $DIC;
 
        $upload = $DIC->upload();
        $has_valid_upload = $upload->hasUploads() && !$upload->hasBeenProcessed();
        if ($_POST['override_entries'] && $has_valid_upload) {
            $upload->process();
            $this->deleteFile();
            $this->moveUploadedFile($upload);
        }
        if ($has_valid_upload) {
            // Delete the object, but leave the db table 'il_bibl_data' for being able to update it using WHERE, and also leave the file
            $this->doDelete(true, true);
            $this->parseFileToDatabase();
        }
 
        $DIC->database()->update(
            "il_bibl_data",
            [
            "filename" => ["text", $this->getFilename()],
            "is_online" => ["integer", $this->getOnline()],
            "file_type" => ["integer", $this->getFileType()],
        ],
            ["id" => ["integer", $this->getId()]]
        );
    }
 
 
    protected function doDelete($leave_out_il_bibl_data = false, $leave_out_delete_file = false)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        if (!$leave_out_delete_file) {
            $this->deleteFile();
        }
        //il_bibl_attribute
        $ilDB->manipulate(
            "DELETE FROM il_bibl_attribute WHERE il_bibl_attribute.entry_id IN " . "(SELECT il_bibl_entry.id FROM il_bibl_entry WHERE il_bibl_entry.data_id = " . $ilDB->quote(
                $this->getId(),
                "integer"
            ) . ")"
        );
        //il_bibl_entry
        $this->bib_entry_factory->deleteEntryById($this->getId());
 
        if (!$leave_out_il_bibl_data) {
            //il_bibl_data
            $ilDB->manipulate(
                "DELETE FROM il_bibl_data WHERE id = " . $ilDB->quote($this->getId(), "integer")
            );
        }
        // delete history entries
        ilHistory::_removeEntriesForObject($this->getId());
    }
 
 
    public function getFileDirectory()
    {
        return "{$this->getType()}/{$this->getId()}";
    }
 
 
    protected function moveUploadedFile(\ILIAS\FileUpload\FileUpload $upload)
    {
        $result = array_values($upload->getResults())[0];
        if ($result->getStatus() == \ILIAS\FileUpload\DTO\ProcessingStatus::OK) {
            $this->deleteFile();
            $upload->moveFilesTo($this->getFileDirectory(), \ILIAS\FileUpload\Location::STORAGE);
            $this->setFilename($result->getName());
        }
    }
 
 
    private function copyFile($file_to_copy)
    {
        $target = $this->getFileDirectory() . '/' . basename($file_to_copy);
        $this->getFileSystem()->copy($file_to_copy, $target);
    }
 
 
    protected function deleteFile()
    {
        $path = $this->getFileDirectory();
        try {
            $this->getFileSystem()->deleteDir($path);
        } catch (\ILIAS\Filesystem\Exception\IOException $e) {
            return false;
        }
 
        return true;
    }
 
 
    private function getFileSystem()
    {
        global $DIC;
 
        return $DIC["filesystem"]->storage();
    }
 
 
    public function getFilePath($without_filename = false)
    {
        $file_name = $this->getFilename();
 
        if ($without_filename) {
            return substr($file_name, 0, strrpos($file_name, DIRECTORY_SEPARATOR));
        } else {
            return $file_name;
        }
    }
 
 
    public function setFilename($filename)
    {
        $this->filename = $filename;
    }
 
 
    public function getFilename()
    {
        return $this->filename;
    }
 
 
    public function getFileAbsolutePath()
    {
        return $this->getFileDirectory() . DIRECTORY_SEPARATOR . $this->getFilename();
    }
 
 
    public function getLegacyAbsolutePath()
    {
        $stream = $this->getFileSystem()->readStream($this->getFileAbsolutePath());
 
        return $stream->getMetadata('uri');
    }
 
 
    public function getFileTypeAsString()
    {
        $type = $this->getFileType();
 
        return $this->bib_type_factory->getInstanceForType($type)->getStringRepresentation();
    }
 
 
    public function getFileType()
    {
        $filename = $this->getFilename();
        if ($filename === null) {
            return ilBiblTypeFactoryInterface::DATA_TYPE_BIBTEX;
        }
        $instance = $this->bib_type_factory->getInstanceForFileName($filename);
 
        return $instance->getId();
    }
 
 
    public function doCloneObject($new_obj, $a_target_id, $a_copy_id = null, $a_omit_tree = false)
    {
        assert($new_obj instanceof ilObjBibliographic);
        //copy online status if object is not the root copy object
        $cp_options = ilCopyWizardOptions::_getInstance($a_copy_id);
 
        if (!$cp_options->isRootNode($this->getRefId())) {
            $new_obj->setOnline($this->getOnline());
        }
 
        $new_obj->cloneStructure($this->getId());
 
        $new_obj->parseFileToDatabase();
 
        return $new_obj;
    }
 
 
    public function cloneStructure($original_id)
    {
        $original = new ilObjBibliographic($original_id);
        $this->setFilename($original->getFilename());
        $this->copyFile($original->getFileAbsolutePath());
        $this->setDescription($original->getDescription());
        $this->setTitle($original->getTitle());
        $this->setType($original->getType());
        $this->doUpdate();
    }
 
 
    public function parseFileToDatabase()
    {
        //Read File
        $type = $this->getFileType();
        $reader = $this->bib_filereader_factory->getByType($type, $this->bib_entry_factory, $this->bib_field_factory, $this->bib_attribute_factory);
        $reader->readContent($this->getFileAbsolutePath());
        $this->entries = $reader->parseContentToEntries($this);
    }
 
 
    public function setFileType($file_type)
    {
        $this->file_type = $file_type;
    }
 
 
    public function setOnline($a_online)
    {
        $this->is_online = $a_online;
    }
 
 
    public function getOnline()
    {
        return $this->is_online;
    }
 
 
    public function determineFileTypeByFileName($filename)
    {
        return $this->bib_type_factory->getInstanceForFileName($filename)->getId();
    }
}