class.ilDataSet.php

Go to the documentation of this file.

<?php

/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */

abstract class ilDataSet
{
    public $dircnt;
    protected $current_installation_id = "";
    
    const EXPORT_NO_INST_ID = 1;
    const EXPORT_ID_ILIAS_LOCAL = 2;
    const EXPORT_ID_ILIAS_LOCAL_INVALID = 3;
    const EXPORT_ID_ILIAS_REMOTE = 4;
    const EXPORT_ID_ILIAS_REMOTE_INVALID = 5;
    const EXPORT_ID = 6;
    const EXPORT_ID_INVALID = 7;

    protected $db;

    protected $ds_log;

    protected $ds_namespace = 'ds';

    public function __construct()
    {
        global $DIC;

        $this->db = $DIC->database();
        $this->ds_log = ilLoggerFactory::getLogger('ds');
    }
    
    final public function init($a_entity, $a_schema_version)
    {
        $this->entity = $a_entity;
        $this->schema_version = $a_schema_version;
        $this->data = array();
    }
    
    abstract public function getSupportedVersions();
        
    abstract protected function getTypes($a_entity, $a_version);
    
    abstract protected function getXmlNamespace($a_entity, $a_schema_version);
    
    abstract public function readData($a_entity, $a_version, $a_ids);
    
    public function setExportDirectories($a_relative, $a_absolute)
    {
        $this->relative_export_dir = $a_relative;
        $this->absolute_export_dir = $a_absolute;
    }

    public function setImportDirectory($a_val)
    {
        $this->import_directory = $a_val;
    }

    public function getImportDirectory()
    {
        return $this->import_directory;
    }

    public function setDSPrefix($a_val)
    {
        $this->ds_namespace = $a_val;
    }

    public function getDSPrefix()
    {
        return $this->ds_namespace;
    }

    public function getDSPrefixString()
    {
        if ($this->getDSPrefix() != "") {
            return $this->getDSPrefix() . ":";
        }
    }

    public function getDirectDataFromQuery($a_query, $a_convert_to_leading_upper = true, $a_set = true)
    {
        $ilDB = $this->db;
        
        $set = $ilDB->query($a_query);
        $this->data = array();
        $ret = [];
        while ($rec = $ilDB->fetchAssoc($set)) {
            if ($a_convert_to_leading_upper) {
                $tmp = array();
                foreach ($rec as $k => $v) {
                    $tmp[$this->convertToLeadingUpper($k)]
                        = $v;
                }
                $rec = $tmp;
            }

            if ($a_set) {
                $this->data[] = $rec;
            }
            $ret[] = $rec;
        }
        return $ret;
    }

    public function convertToLeadingUpper($a_str)
    {
        $a_str = strtoupper(substr($a_str, 0, 1)) . substr($a_str, 1);
        while (is_int($pos = strpos($a_str, "_"))) {
            $a_str = substr($a_str, 0, $pos) .
                strtoupper(substr($a_str, $pos + 1, 1)) .
                substr($a_str, $pos + 2);
        }
        return $a_str;
    }

            
    final public function getJsonRepresentation()
    {
        if ($this->version === false) {
            return false;
        }
        
        $arr["entity"] = $this->getJsonEntityName();
        $arr["version"] = $this->version;
        $arr["install_id"] = IL_INST_ID;
        $arr["install_url"] = ILIAS_HTTP_PATH;
        $arr["types"] = $this->getJsonTypes();
        $arr["set"] = array();
        foreach ($this->data as $d) {
            $arr["set"][] = $this->getJsonRecord($d);
        }
        
        include_once("./Services/JSON/classes/class.ilJsonUtil.php");

        return ilJsonUtil::encode($arr);
    }

    final public function getXmlRepresentation(
        $a_entity,
        $a_schema_version,
        $a_ids,
        $a_field = "",
        $a_omit_header = false,
        $a_omit_types = false
    ) {
        $this->dircnt = 1;
        
        // step 1: check target release and supported versions
        
        
        
        // step 2: init writer
        include_once "./Services/Xml/classes/class.ilXmlWriter.php";
        $writer = new ilXmlWriter();
        if (!$a_omit_header) {
            $writer->xmlHeader();
        }
        
        // collect namespaces
        $namespaces = $prefixes = array();
        $this->getNamespaces($namespaces, $a_entity, $a_schema_version);
        $atts = array("InstallationId" => IL_INST_ID,
            "InstallationUrl" => ILIAS_HTTP_PATH, "TopEntity" => $a_entity);
        $cnt = 1;
        foreach ($namespaces as $entity => $ns) {
            $prefix = "ns" . $cnt;
            $prefixes[$entity] = $prefix;
            //                  $atts["xmlns:".$prefix] = $ns;
            $cnt++;
        }

        $this->ds_log->debug("Start writing Dataset, entity: " . $a_entity . ", schema version: " . $a_schema_version .
            ", ids: " . print_r($a_ids, true));
        $writer->xmlStartTag($this->getDSPrefixString() . 'DataSet', $atts);
        
        // add types
        if (!$a_omit_types) {
            $this->ds_log->debug("...write types");
            $this->addTypesXml($writer, $a_entity, $a_schema_version);
        }
        
        // add records
        $this->ds_log->debug("...write records");
        $this->addRecordsXml($writer, $prefixes, $a_entity, $a_schema_version, $a_ids, $a_field);
        
        
        $writer->xmlEndTag($this->getDSPrefixString() . "DataSet");
        //if ($a_entity == "mep")
        //{
        //      echo "<pre>".htmlentities($writer->xmlDumpMem(true))."</pre>"; exit;
        //}
        return $writer->xmlDumpMem(false);
    }
    
    
    public function addRecordsXml($a_writer, $a_prefixes, $a_entity, $a_schema_version, $a_ids, $a_field = "")
    {
        $types = $this->getXmlTypes($a_entity, $a_schema_version);

        $this->ds_log->debug("...read data");
        $this->readData($a_entity, $a_schema_version, $a_ids, $a_field);
        $this->ds_log->debug("...data: " . print_r($this->data, true));
        if (is_array($this->data)) {
            foreach ($this->data as $d) {
                $a_writer->xmlStartTag(
                    $this->getDSPrefixString() . "Rec",
                    array("Entity" => $this->getXmlEntityName($a_entity, $a_schema_version))
                );

                // entity tag
                $a_writer->xmlStartTag($this->getXmlEntityTag($a_entity, $a_schema_version));

                $rec = $this->getXmlRecord($a_entity, $a_schema_version, $d);
                foreach ($rec as $f => $c) {
                    switch ($types[$f]) {
                        case "directory":
                            if ($this->absolute_export_dir != "" && $this->relative_export_dir != "") {
                                ilUtil::makeDirParents($this->absolute_export_dir . "/dsDir_" . $this->dircnt);
                                ilUtil::rCopy($c, $this->absolute_export_dir . "/dsDir_" . $this->dircnt);
                                //echo "<br>copy-".$c."-".$this->absolute_export_dir."/dsDir_".$this->dircnt."-";
                                $c = $this->relative_export_dir . "/dsDir_" . $this->dircnt;
                                $this->dircnt++;
                            }
                            break;
                    }
                    // this changes schema/dtd
                    //$a_writer->xmlElement($a_prefixes[$a_entity].":".$f,
                    //  array(), $c);
                    $a_writer->xmlElement($f, array(), $c);
                }
                
                $a_writer->xmlEndTag($this->getXmlEntityTag($a_entity, $a_schema_version));

                $a_writer->xmlEndTag($this->getDSPrefixString() . "Rec");
                
                $this->afterXmlRecordWriting($a_entity, $a_schema_version, $d);

                // foreach record records of dependent entities
                $this->ds_log->debug("...get dependencies");
                $deps = $this->getDependencies($a_entity, $a_schema_version, $rec, $a_ids);
                $this->ds_log->debug("...dependencies: " . print_r($deps, true));
                if (is_array($deps)) {
                    foreach ($deps as $dp => $par) {
                        $this->addRecordsXml($a_writer, $a_prefixes, $dp, $a_schema_version, $par["ids"], $par["field"]);
                    }
                }
            }
        } elseif ($this->data === false) {
            // false -> add records of dependent entities (no record)
            $this->ds_log->debug("...get dependencies (no record)");
            $deps = $this->getDependencies($a_entity, $a_schema_version, null, $a_ids);
            if (is_array($deps)) {
                foreach ($deps as $dp => $par) {
                    $this->addRecordsXml($a_writer, $a_prefixes, $dp, $a_schema_version, $par["ids"], $par["field"]);
                }
            }
        }
    }
    
    public function afterXmlRecordWriting($a_entity, $a_version, $a_set)
    {
    }

    private function addTypesXml($a_writer, $a_entity, $a_schema_version)
    {
        $types = $this->getXmlTypes($a_entity, $a_schema_version);
        
        // add types of current entity
        if (is_array($types)) {
            $a_writer->xmlStartTag(
                $this->getDSPrefixString() . "Types",
                array("Entity" => $this->getXmlEntityName($a_entity, $a_schema_version),
                    "SchemaVersion" => $a_schema_version)
            );
            foreach ($this->getXmlTypes($a_entity, $a_schema_version) as $f => $t) {
                $a_writer->xmlElement(
                    $this->getDSPrefixString() . 'FieldType',
                    array("Name" => $f, "Type" => $t)
                );
            }
            $a_writer->xmlEndTag($this->getDSPrefixString() . "Types");
        }
        
        // add types of dependent entities
        $deps = $this->getDependencies($a_entity, $a_schema_version, null, null);
        if (is_array($deps)) {
            foreach ($deps as $dp => $w) {
                $this->addTypesXml($a_writer, $dp, $a_schema_version);
            }
        }
    }
    
    public function getNamespaces(&$namespaces, $a_entity, $a_schema_version)
    {
        $ns = $this->getXmlNamespace($a_entity, $a_schema_version);
        if ($ns != "") {
            $namespaces[$a_entity] = $ns;
        }
        // add types of dependent entities
        $deps = $this->getDependencies($a_entity, $a_schema_version, null, null);
        if (is_array($deps)) {
            foreach ($deps as $dp => $w) {
                $this->getNamespaces($namespaces, $dp, $a_schema_version);
            }
        }
    }
    
    public function getXmlRecord($a_entity, $a_version, $a_set)
    {
        return $a_set;
    }
    
    public function getJsonRecord($a_set)
    {
        return $a_set;
    }
    
    public function getXmlTypes($a_entity, $a_version)
    {
        return $this->getTypes($a_entity, $a_version);
    }
    
    public function getJsonTypes($a_entity, $a_version)
    {
        return $this->getTypes($a_entity, $a_version);
    }
    
    public function getXMLEntityName($a_entity, $a_version)
    {
        return $a_entity;
    }

    public function getXMLEntityTag($a_entity, $a_schema_version)
    {
        return $this->convertToLeadingUpper($a_entity);
    }
    
    public function getJsonEntityName($a_entity, $a_version)
    {
        return $a_entity;
    }
    
    public function setImport($a_val)
    {
        $this->import = $a_val;
    }
    
    public function getImport()
    {
        return $this->import;
    }

    public function setCurrentInstallationId($a_val)
    {
        $this->current_installation_id = $a_val;
    }

    public function getCurrentInstallationId()
    {
        return $this->current_installation_id;
    }
    
    protected function createObjectExportId($a_type, $a_id)
    {
        return "il_" . IL_INST_ID . "_" . $a_type . "_" . $a_id;
    }
        
    protected function parseObjectExportId($a_id, $a_fallback_id = null)
    {
        // ilias export id?
        if (substr($a_id, 0, 3) == "il_") {
            $parts = explode("_", $a_id);
            $inst_id = $parts[1];
            $type = $parts[2];
            $id = $parts[3];
            
            // missing installation ids?
            if (($inst_id == 0 || IL_INST_ID == 0) && !DEVMODE) {
                return array("type" => self::EXPORT_NO_INST_ID, "id" => $a_fallback_id);
            }
                            
            // same installation?
            if ($inst_id == IL_INST_ID) {
                // still existing?
                if (ilObject::_lookupType($id) == $type) {
                    return array("type" => self::EXPORT_ID_ILIAS_LOCAL, "id" => $id);
                }
                // not found
                else {
                    return array("type" => self::EXPORT_ID_ILIAS_LOCAL_INVALID, "id" => $a_fallback_id);
                }
            }
            // different installation
            else {
                $id = ilObject::_getIdForImportId($a_id);
                // matching type?
                if ($id && ilObject::_lookupType($id) == $type) {
                    return array("type" => self::EXPORT_ID_ILIAS_REMOTE, "id" => $id);
                }
                // not found
                else {
                    return array("type" => self::EXPORT_ID_ILIAS_REMOTE_INVALID, "id" => $a_fallback_id);
                }
            }
        }
        
        // external id
        $id = ilObject::_getIdForImportId($a_id);
        if ($id) {
            return array("type" => self::EXPORT_ID, "id" => $id);
        } else {
            return array("type" => self::EXPORT_ID_INVALID, "id" => $a_fallback_id);
        }
    }

    protected function stripTags(array $rec, array $omit_keys = []) : array
    {
        $ret_rec = [];
        foreach ($rec as $k => $v) {
            if (in_array($k, $omit_keys, true)) {
                $ret_rec[$k] = $v;
            } else {
                $ret_rec[$k] = ilUtil::stripSlashes($v);
            }
        }
        return $ret_rec;
    }
}