classes/class.ilObjLanguageFolder.php

Go to the documentation of this file.

<?php
/*
        +-----------------------------------------------------------------------------+
        | ILIAS open source                                                           |
        +-----------------------------------------------------------------------------+
        | Copyright (c) 1998-2001 ILIAS open source, University of Cologne            |
        |                                                                             |
        | This program is free software; you can redistribute it and/or               |
        | modify it under the terms of the GNU General Public License                 |
        | as published by the Free Software Foundation; either version 2              |
        | of the License, or (at your option) any later version.                      |
        |                                                                             |
        | This program is distributed in the hope that it will be useful,             |
        | but WITHOUT ANY WARRANTY; without even the implied warranty of              |
        | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
        | GNU General Public License for more details.                                |
        |                                                                             |
        | You should have received a copy of the GNU General Public License           |
        | along with this program; if not, write to the Free Software                 |
        | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
        +-----------------------------------------------------------------------------+
*/


require_once "class.ilObject.php";

class ilObjLanguageFolder extends ilObject
{
        var $lang_default;

        var $lang_user;

        var $lang_path;

        var $separator;

        var $languages;

        function ilObjLanguageFolder($a_id,$a_call_by_reference = true)
        {
                $this->type = "lngf";
                $this->ilObject($a_id,$a_call_by_reference);

                // init language support
                global $lng;

                $this->lang_path = $lng->lang_path;
                $this->lang_default = $lng->lang_default;
                $this->lang_user = $lng->lang_user;
                $this->separator = $lng->separator;
        }

        function getLanguages ()
        {
                global $lng;
                
                $lng->loadLanguageModule("meta");

                // set path to directory where lang-files reside
                $d = dir($this->lang_path);
                $tmpPath = getcwd();
                chdir ($this->lang_path);

                // get available lang-files
                while ($entry = $d->read())
                {
                        if (is_file($entry) && (ereg ("(^ilias_.{2}\.lang$)", $entry)))
                        {
                                $lang_key = substr($entry,6,2);
                                $languages[$lang_key] = ""; // long names will be set in class Out
                        }
                }

                // ensure that arrays are initiated when no lang file was found
                if (!array($languages))
                {
                        $language = array();
                        $tmp_array = array();
                }

                $tmp_array = array_keys($languages);
                $lang_keys = array();

                // now get languages from database
                if ($lang_db = getObjectList("lng"))
                {
                        foreach ($lang_db as $lang)
                        {
                                // set values
                                $lang_key = $lang["title"];
                                $languages[$lang_key] = $lang;
                                $lang_keys[] = $lang_key;

                                // determine default language and language of current user
                                if ($lang_key == $this->lang_user)
                                {
                                        $languages[$lang_key]["status"] = "in_use";
                                }

                                if ($lang_key == $this->lang_default)
                                {
                                        $languages[$lang_key]["status"] = "system_language";
                                }

                                // check if files are missing
                                if ((count($tmp_array) > 0) && (!in_array($lang_key,$tmp_array)))
                                {
                                        $languages[$lang_key]["info"] = "file_not_found";
                                }
                        }
                }

                // compute new languages
                foreach ($languages as $lang_key => $lang_data)
                {
                        if (!in_array($lang_key,$lang_keys))
                        {
                                $languages[$lang_key]["info"] = "new_language";
                                //$languages[$lang_key]["desc"] = "not_installed";
                        }
                }

                chdir($tmpPath);
                
                // Insert languages with files new found into table language
                $languages = $this->addNewLanguages($languages);

                // Remove from array & db languages which are not installed and no lang-files
                $languages = $this->removeLanguages($languages);

                // setting language's full names
                foreach ($languages as $lang_key => $lang_data)
                {
                        $languages[$lang_key]["name"] = $lng->txt("meta_l_".$lang_key);
                }

                $this->languages = $languages;

                return $this->languages;
        }

        function addNewLanguages($a_languages)
        {
                if (count($a_languages) > 0)
                {
                        foreach ($a_languages as $lang_key => $lang_data)
                        {
                                if ($lang_data["info"] == "new_language")
                                {
                                        include_once("./classes/class.ilObjLanguage.php");
                                        $lngObj =& new ilObjLanguage();
                                        $lngObj->setTitle($lang_key);
                                        $lngObj->setDescription("not_installed");
                                        $lngObj->create();

                                        // must get OOP through the whole class some time
                                        // (no arrays with db fields! this class doesn't know anything about table object!)
                                        $a_languages[$lang_key] = array("obj_id" => $lngObj->getId(),
                                                                                                        "type" => $lngObj->getType(),
                                                                                                        "description" => $lngObj->getDescription(),
                                                                                                        "desc" => $lngObj->getDescription(),
                                                                                                        "owner" => $lngObj->getOwner(),
                                                                                                        "create_date" => $lngObj->getCreateDate(),
                                                                                                        "last_update" => $lngObj->getLastUpdateDate());

                                        $a_languages[$lang_key]["info"] = "new_language";
                                        unset($lngObj);                 // better: the objects should be resident in an member array of this class
                                }
                        }
                }

                return $a_languages;
        }

        function removeLanguages($a_languages)
        {
                foreach ($a_languages as $lang_key => $lang_data)
                {
                        if ($lang_data["desc"] == "not_installed" && $lang_data["info"] == "file_not_found")
                        {
                                // update languages array
                                unset($a_languages[$lang_key]);

                                // update object_data table
                                $query = "DELETE FROM object_data ".
                                                 "WHERE type = 'lng' ".
                                                 "AND title = '".$lang_key."'";
                                $this->ilias->db->query($query);
                        }
                }

                return $a_languages;
        }

        function checkAllLanguages()
        {
                // TODO: lng object should not be used in this class
                global $lng;

                // set path to directory where lang-files reside
                $d = dir($this->lang_path);
                $tmpPath = getcwd();
                chdir ($this->lang_path);

                // for giving a message when no lang-file was found
                $found = false;

                // get available lang-files
                while ($entry = $d->read())
                {
                        if (is_file($entry) && (ereg ("(^ilias_.{2}\.lang$)", $entry)))
                        {
                                // textmeldung, wenn langfile gefunden wurde
                                $output .= "<br/><br/>".$lng->txt("langfile_found").": ".$entry;
                                $content = file ($entry);

                                $found = true;
                                $error = false;

                                if ($content = ilObjLanguage::cut_header($content))
                                {
                                        foreach ($content as $key => $val)
                                        {
                                                $separated = explode ($this->separator,trim($val));
                                                $num = count($separated);

                                                if ($num != 3)
                                                {
                                                        $error = true;
                                                        $line = $key + 37;

                                $output .= "<br/><b/>".$lng->txt("err_in_line")." ".$line." !</b>&nbsp;&nbsp;";
                                $output .= $lng->txt("module").": ".$separated[0];
                                $output .= ", ".$lng->txt("identifier").": ".$separated[1];
                                $output .= ", ".$lng->txt("value").": ".$separated[2];

                                                        switch ($num)
                                                        {
                                                                case 1:
                                                                        if (empty($separated[0]))
                                                                        {
                                                                                $output .= "<br/>".$lng->txt("err_no_param")." ".$lng->txt("check_langfile");
                                                                        }
                                                                        else
                                                                        {
                                                                                $output .= "<br/>".$lng->txt("err_1_param")." ".$lng->txt("check_langfile");
                                                                        }
                                                                break;

                                                                case 2:
                                                                        $output .= "<br/>".$lng->txt("err_2_param")." ".$lng->txt("check_langfile");
                                                                break;

                                                                default:
                                                                        $output .= "<br/>".$lng->txt("err_over_3_param")." ".$lng->txt("check_langfile");
                                                                break;
                                                        }
                                                }
                                        }

                                        if ($error) {
                                                $output .= "<br/>".$lng->txt("file_not_valid")." ".$lng->txt("err_count_param");
                                        }
                                        else {
                                                $output .= "<br/>".$lng->txt("file_valid");
                                        }
                                }
                                else {
                                        $output .= "<br/>".$lng->txt("file_not_valid")." ".$lng->txt("err_wrong_header");
                                }
                        }
                }

                $d->close();

                if (!$found) {
                        $output .= "<br/>".$lng->txt("err_no_langfile_found");
                }

                chdir($tmpPath);
                return $output;
        }
} // END class.LanguageFolderObject
?>