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
{
        var $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;
                
        
        function __construct()
        {
                $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 function readData($a_entity, $a_version, $a_ids);
        
        function setExportDirectories($a_relative, $a_absolute)
        {
                $this->relative_export_dir = $a_relative;
                $this->absolute_export_dir = $a_absolute;
        }

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

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

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

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

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

        function getDirectDataFromQuery($a_query, $a_convert_to_leading_upper = true, $a_set = true)
        {
                global $ilDB;
                
                $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;
        }

        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 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 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);
        }
        
        
        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"]);
                                        }
                                }
                        }
                }
                else if ($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"]);
                                }
                        }
                }
        }
        
        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);
                        }
                }
                
        }
        
        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);
                        }
                }
        }
        
        function getXmlRecord($a_entity, $a_version, $a_set)
        {
                return $a_set;
        }
        
        function getJsonRecord($a_set)
        {
                return $a_set;          
        }
        
        function getXmlTypes($a_entity, $a_version)
        {
                return $this->getTypes($a_entity, $a_version);
        }
        
        function getJsonTypes($a_entity, $a_version)
        {
                return $this->getTypes($a_entity, $a_version);
        }
        
        function getXMLEntityName($a_entity, $a_version)
        {
                return $a_entity;
        }

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

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

        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);
                }                               
        }
}

?>