<?php

/**
 * File:
 * class.module.php
 *
 * Description:
 *  cApi class
 * 
 * @package Core
 * @subpackage cApi
 * @version $Rev$
 * @since 2.0
 * @author Ortwin Pinke <o.pinke@conlite.org>
 * @copyright (c) 2015, conlite.org
 * @license http://www.gnu.de/documents/gpl.en.html GPL v3 (english version)
 * @license http://www.gnu.de/documents/gpl.de.html GPL v3 (deutsche Version)
 * @link http://www.conlite.org ConLite.org
 * 
 * $Id$
 */
if (!defined('CON_FRAMEWORK')) {
    die('Illegal call');
}

cInclude('includes', 'functions.upl.php');

class cApiModuleCollection extends ItemCollection {

    /**
     * Constructor Function
     * @param none
     */
    public function __construct() {
        global $cfg;
        parent::__construct($cfg["tab"]["mod"], "idmod");
        $this->_setItemClass("cApiModule");
    }

    /**
     * Creates a new communication item
     */
    public function create($name) {
        global $auth, $client;
        $item = parent::createNewItem();

        $item->set("idclient", $client);
        $item->set("name", $name);
        $item->set("author", $auth->auth["uid"]);
        $item->set("created", date("Y-m-d H:i:s"), false);
        $item->store();
        return $item;
    }

    public function delete($iIdMod) {
        /* @var $oMod cApiModule */
        $oMod = $this->_itemClassInstance;
        $oMod->_bNoted = TRUE;
        $oMod->loadByPrimaryKey($iIdMod);
        if ($oMod->isLoaded()) {
            if ($oMod->hasModuleFolder()) {
                $oMod->deleteModuleFolder();
            }
        }
        unset($oMod);
        return parent::delete($iIdMod);
    }

}

/**
 * Module access class
 */
class cApiModule extends Item {

    protected $_error;

    /**
     * Assoziative package structure array
     * @var array
     */
    protected $_packageStructure;
    protected $_bOutputFromFile = false;
    protected $_bInputFromFile = false;

    /**
     * @var array
     */
    private $aUsedTemplates = array();

    /**
     * Configuration Array of ModFileEdit
     * array is set with entries in local config file
     * 
     * @var array 
     */
    private $_aModFileEditConf = array(
        'use' => false,
        'modFolderName' => 'data/modules'
    );

    /**
     *
     * @var string 
     */
    private $_sModAlias;

    /**
     *
     * @var string
     */
    private $_sModPath;
    private $_aModDefaultStruct = array(
        'css', 'js', 'php', 'template', 'image', 'lang', 'xml'
    );

    /**
     * Constructor Function
     * @param  mixed  $mId  Specifies the ID of item to load
     */
    public function __construct($mId = false) {
        global $cfg, $cfgClient, $client;
        
        parent::__construct($cfg["tab"]["mod"], "idmod");

        // Using no filters is just for compatibility reasons.
        // That's why you don't have to stripslashes values if you store them
        // using ->set. You have to add slashes, if you store data directly
        // (data not from a form field)
        $this->setFilters(array(), array());

        $this->_packageStructure = array("jsfiles" => $cfgClient[$client]["js"]["path"],
            "tplfiles" => $cfgClient[$client]["tpl"]["path"],
            "cssfiles" => $cfgClient[$client]["css"]["path"]);

        if (isset($cfg['dceModEdit']) && is_array($cfg['dceModEdit'])) {
            $this->_aModFileEditConf['clientPath'] = $cfgClient[$client]["path"]["frontend"];
            $this->_aModFileEditConf = array_merge($this->_aModFileEditConf, $cfg['dceModEdit']);
            if (!isset($cfg['dceModEdit']['modPath']) || empty($cfg['dceModEdit']['modPath'])) {
                $this->_aModFileEditConf['modPath'] = $cfgClient[$client]["path"]["frontend"]
                        . $this->_aModFileEditConf['modFolderName'] . "/";
            }
        }

        $oClient = new cApiClient($client);
        $aClientProp = $oClient->getPropertiesByType('modfileedit');
        if (count($aClientProp) > 0) {
            $this->_aModFileEditConf = array_merge($this->_aModFileEditConf, $aClientProp);
        }

        if ($mId !== false) {
            $this->loadByPrimaryKey($mId);
        }
    }

    public function createModuleFolder() {
        //echo $this->_aModFileEditConf['modPath'];
        $sPathErrorLog = cRegistry::getConfigValue('path', 'logs').'errorlog.txt';
        
        if (is_writable($this->_aModFileEditConf['clientPath']) && !file_exists($this->_aModFileEditConf['modPath'])) {
            try {
                mkdir($this->_aModFileEditConf['modPath'], 0777, true);
            } catch (Exception $ex) {
                $oWriter = cLogWriter::factory("File", array('destination' => $sPathErrorLog));
                $oLog = new cLog($oWriter);
                $oLog->log($ex->getFile() . " (" . $ex->getLine() . "): " . $ex->getMessage(), cLog::WARN);
            }
        }

        if ($this->_aModFileEditConf['use'] == true && is_writable($this->_aModFileEditConf['modPath'])) {
            if (!is_dir($this->getModulePath())) {
                $this->_oldumask = umask(0);
                try {
                    mkdir($this->getModulePath(), 0777);
                } catch (Exception $ex) {
                    $oWriter = cLogWriter::factory("File", array('destination' => $sPathErrorLog));
                    $oLog = new cLog($oWriter);
                    $oLog->log($ex->getFile() . " (" . $ex->getLine() . "): " . $ex->getMessage(), cLog::WARN);
                }

                if (is_writable($this->getModulePath())) {
                    return $this->_createModuleStruct();
                }
                umask($this->_oldumask);
            }
        } else {
            $oWriter = cLogWriter::factory("File", array('destination' => $sPathErrorLog));
            $oLog = new cLog($oWriter);
            $oLog->log(__FILE__ . " (" . __LINE__ . "): " . 'Error: Cannot create mod path '.$this->getModulePath(), cLog::WARN);
        }
        return FALSE;
    }

    public function deleteModuleFolder() {
        if ($this->_aModFileEditConf['use'] == TRUE && is_writable($this->_aModFileEditConf['modPath'])) {
            if (is_dir($this->getModulePath())) {
                return $this->_recursiveRemoveDirectory($this->getModulePath());
            }
        }
        return FALSE;
    }

    public function getModuleAlias() {
        return $this->_sModAlias;
    }

    public function hasModuleFolder() {
        $sOldPath = $this->_aModFileEditConf['modPath'] . uplCreateFriendlyName($this->get("name"));
        return (file_exists($this->getModulePath()) || file_exists($sOldPath));
    }

    public function getModulePath() {
        if (empty($this->_sModPath)) {
            $this->_setModulePath();
        }
        return $this->_sModPath;
    }

    protected function _setModulePath() {
        $this->_sModPath = $this->_aModFileEditConf['modPath'] . $this->getModuleAlias() . "/";
    }

    /**
     * Returns the translated name of the module if a translation exists.
     *
     * @param none
     * @return string Translated module name or original
     */
    public function getTranslatedName() {
        global $lang;

        // If we're not loaded, return
        if ($this->virgin == true) {
            return false;
        }

        $modname = $this->getProperty("translated-name", $lang);

        if ($modname === false) {
            return $this->get("name");
        } else {
            return $modname;
        }
    }

    /**
     * Sets the translated name of the module
     *
     * @param $name string Translated name of the module
     * @return none
     */
    public function setTranslatedName($name) {
        global $lang;
        $this->setProperty("translated-name", $lang, $name);
    }

    /**
     * Parses the module for mi18n strings and returns them in an array
     *
     * @return array Found strings for this module
     */
    public function parseModuleForStrings() {
        if ($this->virgin == true) {
            return false;
        }

        // Fetch the code, append input to output
        $code = $this->get("output");
        $code .= $this->get("input");

        // Initialize array
        $strings = array();

        // Split the code into mi18n chunks
        $varr = preg_split('/mi18n([\s]*)\(([\s]*)"/', $code, -1);

        if (count($varr) > 1) {
            foreach ($varr as $key => $value) {
                // Search first closing
                $closing = strpos($value, '")');

                if ($closing === false) {
                    $closing = strpos($value, '" )');
                }

                if ($closing !== false) {
                    $value = substr($value, 0, $closing) . '")';
                }

                // Append mi18n again
                $varr[$key] = 'mi18n("' . $value;

                // Parse for the mi18n stuff
                preg_match_all('/mi18n([\s]*)\("(.*)"\)/', $varr[$key], $results);

                // Append to strings array if there are any results
                if (is_array($results[1]) && count($results[2]) > 0) {
                    $strings = array_merge($strings, $results[2]);
                }

                // Unset the results for the next run
                unset($results);
            }
        }

        // adding dynamically new module translations by content types
        // this function was introduced with contenido 4.8.13
        // checking if array is set to prevent crashing the module translation page
        if (is_array($cfg['translatable_content_types']) && count($cfg['translatable_content_types']) > 0) {
            // iterate over all defines cms content types
            foreach ($cfg['translatable_content_types'] as $sContentType) {
                // check if the content type exists and include his class file
                if (file_exists($cfg['contenido']['path'] . "classes/class." . strtolower($sContentType) . ".php")) {
                    cInclude("classes", "class." . strtolower($sContentType) . ".php");
                    // if the class exists, has the method "addModuleTranslations"
                    // and the current module contains this cms content type we
                    // add the additional translations for the module
                    if (class_exists($sContentType) && method_exists($sContentType, 'addModuleTranslations') && preg_match('/' . strtoupper($sContentType) . '\[\d+\]/', $code)) {

                        $strings = call_user_func(array($sContentType, 'addModuleTranslations'), $strings);
                    }
                }
            }
        }

        // Make the strings unique
        return array_unique($strings);
    }

    /**
     * Checks if the module is in use
     * @return bool    Specifies if the module is in use
     */
    public function moduleInUse($module, $bSetData = false) {
        global $cfg;

        $db = new DB_ConLite();

        $sql = "SELECT
                    c.idmod, c.idtpl, t.name
                FROM
                " . $cfg["tab"]["container"] . " as c,
                " . $cfg["tab"]["tpl"] . " as t
                WHERE
                    c.idmod = '" . Contenido_Security::toInteger($module) . "' AND
                    t.idtpl=c.idtpl
                GROUP BY c.idtpl
                ORDER BY t.name";
        $db->query($sql);

        if ($db->nf() == 0) {
            return false;
        } else {
            $i = 0;
            // save the datas of used templates in array
            if ($bSetData === true) {
                while ($db->next_record()) {
                    $this->aUsedTemplates[$i]['tpl_name'] = $db->f('name');
                    $this->aUsedTemplates[$i]['tpl_id'] = (int) $db->f('idmod');
                    $i++;
                }
            }

            return true;
        }
    }

    /**
     * Get the informations of used templates
     * @return array template data
     */
    public function getUsedTemplates() {
        return $this->aUsedTemplates;
    }

    /**
     * Checks if the module is a pre-4.3 module
     * @return boolean true if this module is an old one
     */
    public function isOldModule() {
        // Keywords to scan
        $scanKeywords = array('$cfgTab', 'idside', 'idsidelang');

        $input = $this->get("input");
        $output = $this->get("output");

        foreach ($scanKeywords as $keyword) {
            if (strstr($input, $keyword)) {
                return true;
            }
            if (strstr($output, $keyword)) {
                return true;
            }
        }
    }

    public function getField($field) {
        $value = parent::getField($field);

        switch ($field) {
            case "name":
                if ($value == "") {
                    $value = i18n("- Unnamed Module -");
                }
        }
        return ($value);
    }

    public function store($bJustStore = false) {
        global $cfg;
        /* dceModFileEdit (c)2009-2011 www.dceonline.de */
        if ($this->_aModFileEditConf['use'] == true && ($this->_aModFileEditConf['allModsFromFile'] == true || in_array($this->get('idmod'), $this->_aModFileEditConf['modsFromFile']))) {
            $this->modifiedValues['output'] = true;
            $this->modifiedValues['input'] = true;
        }
        /* End dceModFileEdit (c)2009-2011 www.dceonline.de */
        if ($bJustStore) {
            // Just store changes, e.g. if specifying the mod package
            parent::store();
        } else {
            cInclude("includes", "functions.con.php");

            parent::store();

            conGenerateCodeForAllArtsUsingMod($this->get("idmod"));

            if ($this->_shouldStoreToFile()) {
                if ($this->_makeFileDirectoryStructure()) {
                    $sRootPath = $cfg['path']['contenido'] . $cfg['path']['modules'] . $this->get("idclient") . "/";
                    file_put_contents($sRootPath . $this->get("idmod") . ".xml", $this->export($this->get("idmod") . ".xml", true));
                }
            }
        }
    }

    public function getModFileEditConf() {
        return $this->_aModFileEditConf;
    }

    protected function _recursiveRemoveDirectory($directory) {
        foreach (glob("{$directory}/*") as $file) {
            if (is_dir($file)) {
                $this->_recursiveRemoveDirectory($file);
            } else {
                unlink($file);
            }
        }
        return rmdir($directory);
    }

    protected function _makeFileDirectoryStructure() {
        global $cfg;

        $sRootPath = $cfg['path']['contenido'] . $cfg['path']['modules'];
        if (!is_dir($sRootPath)) {
            @mkdir($sRootPath);
        }

        $sRootPath = $cfg['path']['contenido'] . $cfg['path']['modules'] . $this->get("idclient") . "/";
        if (!is_dir($sRootPath)) {
            @mkdir($sRootPath);
        }

        if (is_dir($sRootPath)) {
            return true;
        } else {
            return false;
        }
    }

    protected function _shouldStoreToFile() {
        if (getSystemProperty("modules", "storeasfiles") == "true") {
            return true;
        } else {
            return false;
        }
    }

    protected function _shouldLoadFromFiles() {
        if (getSystemProperty("modules", "loadfromfiles") == "true") {
            return true;
        } else {
            return false;
        }
    }

    /**
     *  Parse import xml file, stores data in global variable (-> event handler functions)
     *
     * @param string $sFile Filename including path of import xml file
     * @param string $sType Import type, "module" or "package"
     * @return bool Returns true, if file has been parsed
     */
    private function _parseImportFile($sFile, $sType = "module", $sEncoding = "ISO-8859-1") {
        global $_mImport;

        $oParser = new XmlParser($sEncoding);

        if ($sType == "module") {
            $oParser->setEventHandlers(array("/module/name" => "cHandler_ModuleData",
                "/module/description" => "cHandler_ModuleData",
                "/module/type" => "cHandler_ModuleData",
                "/module/input" => "cHandler_ModuleData",
                "/module/output" => "cHandler_ModuleData"));
        } else {
            $aHandler = array("/modulepackage/guid" => "cHandler_ModuleData",
                #"/modulepackage/repository_guid"    => "cHandler_ModuleData",
                "/modulepackage/module/name" => "cHandler_ModuleData",
                "/modulepackage/module/description" => "cHandler_ModuleData",
                "/modulepackage/module/type" => "cHandler_ModuleData",
                "/modulepackage/module/input" => "cHandler_ModuleData",
                "/modulepackage/module/output" => "cHandler_ModuleData",
                "/modulepackage/module/input" => "cHandler_ModuleData");

            // Add file handler (e.g. js, css, templates)
            foreach ($this->_packageStructure As $sFileType => $sFilePath) {
                // Note, that $aHandler["/modulepackage/" . $sFileType] and using
                // a handler which uses the node name (here: FileType) doesn't work,
                // as the event handler for the filetype node will be fired
                // after the node has been successfully parsed, not before.
                // So, we have a little redundancy here, but maybe we need
                // this in the future.
                $aHandler["/modulepackage/" . $sFileType . "/area"] = "cHandler_ItemArea";
                $aHandler["/modulepackage/" . $sFileType . "/name"] = "cHandler_ItemName";
                $aHandler["/modulepackage/" . $sFileType . "/content"] = "cHandler_ItemData";
            }

            // Layouts
            $aHandler["/modulepackage/layouts/area"] = "cHandler_ItemArea";
            $aHandler["/modulepackage/layouts/name"] = "cHandler_ItemName";
            $aHandler["/modulepackage/layouts/description"] = "cHandler_ItemData";
            $aHandler["/modulepackage/layouts/content"] = "cHandler_ItemData";

            // Translations
            $aHandler["/modulepackage/translations/language"] = "cHandler_ItemArea";
            $aHandler["/modulepackage/translations/string/original"] = "cHandler_ItemName";
            $aHandler["/modulepackage/translations/string/translation"] = "cHandler_Translation";

            $oParser->setEventHandlers($aHandler);
        }

        if ($oParser->parseFile($sFile)) {
            return true;
        } else {
            $this->_error = $oParser->error;
            return false;
        }
    }

    /**
     * Imports the a module from a XML file
     * Uses xmlparser and callbacks
     *
     * @param string    $file     Filename of data file (full path)
     */
    public function import($sFile) {
        global $_mImport;

        if ($this->_parseImportFile($sFile, "module")) {
            $bStore = false;
            foreach ($_mImport["module"] as $key => $value) {
                if ($this->get($key) != $value) {
                    $this->set($key, addslashes($value));
                    $bStore = true;
                }
            }

            if ($bStore == true) {
                $this->store();
            }
            return true;
        } else {
            return false;
        }
    }

    /**
     * Exports the specified module strings to a file
     *
     * @param $filename string Filename to return
     * @param $return    boolean if false, the result is immediately sent to the browser
     */
    public function export($filename, $return = false) {
        $tree = new XmlTree('1.0', 'ISO-8859-1');
        $root = & $tree->addRoot('module');

        $root->appendChild("name", clHtmlSpecialChars($this->get("name")));
        $root->appendChild("description", clHtmlSpecialChars($this->get("description")));
        $root->appendChild("type", clHtmlSpecialChars($this->get("type")));
        $root->appendChild("input", clHtmlSpecialChars($this->get("input")));
        $root->appendChild("output", clHtmlSpecialChars($this->get("output")));

        if ($return == false) {
            ob_end_clean();
            header("Content-Type: text/xml");
            header("Etag: " . md5(mt_rand()));
            header("Content-Disposition: attachment;filename=\"$filename\"");
            $tree->dump(false);
        } else {
            return stripslashes($tree->dump(true));
        }
    }

    public function getPackageOverview($sFile) {
        global $_mImport;

        if ($this->_parseImportFile($sFile, "package")) {
            $aData = array();
            $aData["guid"] = $_mImport["module"]["guid"];
            $aData["repository_guid"] = $_mImport["module"]["repository_guid"];
            $aData["name"] = $_mImport["module"]["name"];

            // Files
            foreach ($this->_packageStructure as $sFileType => $sFilePath) {
                if (is_array($_mImport["items"][$sFileType])) {
                    $aData[$sFileType] = array_keys($_mImport["items"][$sFileType]);
                }
            }

            // Layouts
            if (is_array($_mImport["items"]["layouts"])) {
                $aData["layouts"] = array_keys($_mImport["items"]["layouts"]);
            }

            // Translation languages
            if (is_array($_mImport["translations"])) {
                $aData["translations"] = array_keys($_mImport["translations"]);
            }

            return $aData;
        } else {
            return false;
        }
    }

    /**
     * Imports a module package from a XML file Uses xmlparser and callbacks
     *
     * @param string    $sFile         Filename of data file (including path)
     * @param array        $aOptions    Optional. An array of arrays specifying, how the items
     *                                 of the xml file will be imported. If specified, has to
     *                                 contain an array of this structure:
     *
     * $aOptions["items"][<filetype>][<clHtmlSpecialChars(filename)>]                = "skip", "append" or "overwrite";
     * $aOptions["translations"][<PackageLanguage>]    = <AssignedIDLang>;
     *
     *                                 If a file is not mentioned in the $aOptions["items"][<filetype>]
     *                                 array, it is new and will be imported.
     *
     *                                 If a <PackageLang> is not found in $aOptions["translations"],
     *                                 then the translations for this language will be ignored
     *
     * @return bool Returns true, if import has been successfully finished
     */
    public function importPackage($sFile, $aOptions = array()) {
        global $_mImport, $client;

        cInclude("includes", "functions.file.php");
        cInclude("includes", "functions.lay.php"); // You won't believe the code in there (or what is missing in class.layout.php...)
        // Ensure correct options structure
        foreach ($this->_packageStructure as $sFileType => $sFilePath) {
            if (!is_array($aOptions["items"][$sFileType])) {
                $aOptions["items"][$sFileType] = array();
            }
        }

        // Layouts
        if (!is_array($aOptions["items"]["layouts"])) {
            $aOptions["items"]["layouts"] = array();
        }

        // Translations
        if (!is_array($aOptions["translations"])) {
            $aOptions["translations"] = array();
        }

        // Parse file
        if ($this->_parseImportFile($sFile, "package")) {
            // Import data
            // Module
            foreach ($_mImport["module"] as $sKey => $sData) {
                if ($this->get($sKey) != $sData) {
                    $this->set($sKey, addslashes($sData));
                    $bStore = true;
                }
            }

            if ($bStore == true) {
                $this->store();
            }

            // Files
            foreach ($this->_packageStructure as $sFileType => $sFilePath) {
                if (is_array($_mImport["items"][$sFileType])) {
                    foreach ($_mImport["items"][$sFileType] as $sFileName => $aContent) {
                        if (!array_key_exists(clHtmlSpecialChars($sFileName), $aOptions["items"][$sFileType]) || $aOptions["items"][$sFileType][clHtmlSpecialChars($sFileName)] == "overwrite") {
                            if (!file_exists($sFilePath . $sFileName)) {
                                createFile($sFileName, $sFilePath);
                            }
                            fileEdit($sFileName, $aContent["content"], $sFilePath);
                        } else if ($aOptions["items"][$sFileType][clHtmlSpecialChars($sFileName)] == "append") {
                            $sOriginalContent = getFileContent($sFileName, $sFilePath);
                            fileEdit($sFileName, $sOriginalContent . $aContent["content"], $sFilePath);
                        }
                    }
                }
            }

            // Layouts
            if (is_array($_mImport["items"]["layouts"])) {
                foreach ($_mImport["items"]["layouts"] as $sLayout => $aContent) {
                    if (!array_key_exists(clHtmlSpecialChars($sLayout), $aOptions["items"]["layouts"]) || $aOptions["items"]["layouts"][clHtmlSpecialChars($sLayout)] == "overwrite") {
                        $oLayouts = new cApiLayoutCollection;
                        $oLayouts->setWhere("idclient", $client);
                        $oLayouts->setWhere("name", $sLayout);
                        $oLayouts->query();

                        if (!$oLayout = $oLayouts->next()) {
                            layEditLayout(false, addslashes($sLayout), addslashes($aContent["description"]), addslashes($aContent["content"]));
                        } else {
                            layEditLayout($oLayout->get($oLayout->primaryKey), addslashes($sLayout), addslashes($aContent["description"]), addslashes($aContent["content"]));
                        }
                    } elseif ($aOptions["items"]["layouts"][clHtmlSpecialChars($sLayout)] == "append") {
                        $oLayouts = new cApiLayoutCollection;
                        $oLayouts->setWhere("idclient", $client);
                        $oLayouts->setWhere("name", $sLayout);
                        $oLayouts->query();

                        if (!$oLayout = $oLayouts->next()) {
                            layEditLayout(false, addslashes($sLayout), addslashes($aContent["description"]), addslashes($aContent["content"]));
                        } else {
                            layEditLayout($oLayout->get($oLayout->primaryKey), addslashes($sLayout), addslashes($oLayout->get("description") . $aContent["description"]), addslashes($oLayout->get("code") . $aContent["content"]));
                        }
                    }
                }
            }

            // Translations
            if (is_array($_mImport["translations"])) {
                $oTranslations = new cApiModuleTranslationCollection();
                $iID = $this->get($this->primaryKey);

                foreach ($_mImport["translations"] as $sPackageLang => $aTranslations) {
                    if (array_key_exists($sPackageLang, $aOptions["translations"])) {
                        foreach ($_mImport["translations"][$sPackageLang] as $sOriginal => $sTranslation) {
                            $oTranslations->create($iID, $aOptions["translations"][$sPackageLang], $sOriginal, $sTranslation);
                        }
                    }
                }
            }
            return true;
        } else {
            return false;
        }
    }

    /**
     * Exports the specified module and attached files to a file
     *
     * @param string    $sPackageFileName    Filename to return
     * @param bool        $bReturn            if false, the result is immediately sent to the browser
     */
    public function exportPackage($sPackageFileName, $bReturn = false) {
        global $cfgClient, $client;

        cInclude("includes", "functions.file.php");

        $oTree = new XmlTree('1.0', 'ISO-8859-1');
        $oRoot = & $oTree->addRoot('modulepackage');

        $oRoot->appendChild("package_guid", $this->get("package_guid"));
        $oRoot->appendChild("package_data", $this->get("package_data")); // This is serialized and more or less informal data

        $aData = unserialize($this->get("package_data"));
        if (!is_array($aData)) {
            $aData = array();
            $aData["repository_guid"] = "";
            $aData["jsfiles"] = array();
            $aData["tplfiles"] = array();
            $aData["cssfiles"] = array();
            $aData["layouts"] = array();
            $aData["translations"] = array();
        }

        // Export basic module
        $oNodeModule = & $oRoot->appendChild("module");
        $oNodeModule->appendChild("name", clHtmlSpecialChars($this->get("name")));
        $oNodeModule->appendChild("description", clHtmlSpecialChars($this->get("description")));
        $oNodeModule->appendChild("type", clHtmlSpecialChars($this->get("type")));
        $oNodeModule->appendChild("input", clHtmlSpecialChars($this->get("input")));
        $oNodeModule->appendChild("output", clHtmlSpecialChars($this->get("output")));

        // Export files (e.g. js, css, templates)
        foreach ($this->_packageStructure As $sFileType => $sFilePath) {
            $oNodeFiles = & $oRoot->appendChild($sFileType);
            if (count($aData[$sFileType]) > 0) {
                foreach ($aData[$sFileType] as $sFileName) {
                    if (is_readable($sFilePath . $sFileName)) {
                        $sContent = getFileContent($sFileName, $sFilePath);
                        $oNodeFiles->appendChild("area", clHtmlSpecialChars($sFileType));
                        $oNodeFiles->appendChild("name", clHtmlSpecialChars($sFileName));
                        $oNodeFiles->appendChild("content", clHtmlSpecialChars($sContent));
                    }
                }
            }
        }
        unset($sContent);

        // Export layouts
        $oNodeLayouts = & $oRoot->appendChild("layouts");

        $oLayouts = new cApiLayoutCollection;
        $oLayouts->setWhere("idclient", $client);
        $oLayouts->query();

        while ($oLayout = $oLayouts->next()) {
            if (in_array($oLayout->get($oLayout->primaryKey), $aData["layouts"])) {
                $oNodeLayouts->appendChild("area", "layouts");
                $oNodeLayouts->appendChild("name", clHtmlSpecialChars($oLayout->get("name")));
                $oNodeLayouts->appendChild("description", clHtmlSpecialChars($oLayout->get("description")));
                $oNodeLayouts->appendChild("content", clHtmlSpecialChars($oLayout->get("code")));
            }
        }
        unset($oLayout);
        unset($oLayouts);

        // Export translations
        $oLangs = new cApiLanguageCollection();
        $oLangs->setOrder("idlang");
        $oLangs->query();

        if ($oLangs->count() > 0) {
            $iIDMod = $this->get($this->primaryKey);
            while ($oLang = $oLangs->next()) {
                $iID = $oLang->get($oLang->primaryKey);

                if (in_array($iID, $aData["translations"])) {
                    $oNodeTrans = & $oRoot->appendChild("translations");
                    // This is nice, but it doesn't help so much,
                    // as this data is available too late on import ...
                    $oNodeTrans->setNodeAttribs(array("origin-language-id" => $iID,
                        "origin-language-name" => clHtmlSpecialChars($oLang->get("name"))));
                    // ... so we store the important information with the data
                    $oNodeTrans->appendChild("language", clHtmlSpecialChars($oLang->get("name")));

                    $oTranslations = new cApiModuleTranslationCollection;
                    $oTranslations->setWhere("idmod", $iIDMod);
                    $oTranslations->setWhere("idlang", $iID);
                    $oTranslations->query();

                    while ($oTranslation = $oTranslations->next()) {
                        $oNodeString = & $oNodeTrans->appendChild("string");
                        $oNodeString->appendChild("original", clHtmlSpecialChars($oTranslation->get("original")));
                        $oNodeString->appendChild("translation", clHtmlSpecialChars($oTranslation->get("translation")));
                    }
                }
            }
        }
        unset($oLangs);
        unset($oLang);

        if ($bReturn == false) {
            ob_end_clean();
            header("Content-Type: text/xml");
            header("Etag: " . md5(mt_rand()));
            header("Content-Disposition: attachment;filename=\"$sPackageFileName\"");
            $oTree->dump(false);
        } else {
            return stripslashes($oTree->dump(true));
        }
    }

    /* dceModFileEdit (c)2009-2012 www.dceonline.de */

    /**
     * Overridden parent method for hooking dceModFileEdit
     * 
     * @return void
     */
    protected function _onLoad() {
        $this->_sModAlias = strtolower(uplCreateFriendlyName($this->get('name')));
        $this->_sModAliasOld = uplCreateFriendlyName($this->get('name'));
        $this->_setOutputFromPhpFile();
        $this->_setInputFromPhpFile();
    }

    /**
     * Use a PHP-file, if present, for module output
     * 
     * @return boolean
     */
    private function _setOutputFromPhpFile() {
        // dceModEdit not enabled or not present
        if ($this->_aModFileEditConf['use'] !== true) {
            return false;
        }
        return $this->_setFieldFromFile('output', $this->_sModAlias . "_output.php");
    }

    /**
     * Use a PHP-file, if present, for module input
     * 
     * @return boolean
     */
    private function _setInputFromPhpFile() {
        cInclude('includes', 'functions.upl.php');
        // dceModEdit not enabled or not present
        if ($this->_aModFileEditConf['use'] !== true) {
            return false;
        }
        return $this->_setFieldFromFile('input', $this->_sModAlias . "_input.php");
    }

    private function _displayNoteFromFile($bIsOldPath = FALSE) {
        if (isset($this->_bNoted) && $this->_bNoted === true) {
            return;
        }
        global $frame, $area;
        if ($frame == 4 && $area == 'mod_edit') {
            $sAddMess = '';
            if ($bIsOldPath) {
                $sAddMess .= "<br>" . i18n("Using old CamelCase for name of modulefolder. You may lowercase the name for modulefolder");
            }
            $oNote = new Contenido_Notification();
            $oNote->displayNotification('warning', i18n("Module uses Output- and/or InputFromFile. Editing and Saving may not be possible in backend.") . $sAddMess);
            $this->_bNoted = true;
        }
    }

    /**
     * read file and set an object field
     * 
     * @param string $sFile 
     * @param string $sField
     * @return boolean
     */
    private function _setFieldFromFile($sField, $sFile) {
        $bIsOldPath = TRUE;
        $sFile = strtolower($sFile);
        if (FALSE === strstr($sFile, $this->_aModFileEditConf['modPath'])) {
            $sFile = $this->_aModFileEditConf['modPath'] . $sFile;
        }
        // check for new struct since CL 2.0
        if (is_dir($this->_aModFileEditConf['modPath'] . $this->_sModAlias) && is_writable($this->_aModFileEditConf['modPath'] . $this->_sModAlias) && file_exists($this->_aModFileEditConf['modPath'] .
                        $this->_sModAlias . "/php/" . $this->_sModAlias .
                        "_" . $sField . ".php")) {
            $sFile = $this->_aModFileEditConf['modPath'] .
                    $this->_sModAlias . "/php/" . $this->_sModAlias .
                    "_" . $sField . ".php";
            $bIsOldPath = FALSE;
        }

        if (is_file($sFile) && is_readable($sFile)) {
            $iFileSize = (int) filesize($sFile);
            if ($iFileSize > 0 && $fh = fopen($sFile, 'r')) {
                $this->set($sField, fread($fh, $iFileSize), false);
                fclose($fh);
                switch ($sField) {
                    case "output":
                        $this->_bOutputFromFile = true;
                        break;
                    case "input":
                        $this->_bInputFromFile = true;
                    default:
                        break;
                }
                $this->_displayNoteFromFile($bIsOldPath);
                return true;
            }
        } else {
            switch ($sField) {
                case "output":
                    $this->_bOutputFromFile = false;
                    break;
                case "input":
                    $this->_bInputFromFile = false;
                default:
                    break;
            }
        }
        return false;
    }

    public function isLoadedFromFile($sWhat = "all") {
        switch ($sWhat) {
            case "all":
                return (($this->_bOutputFromFile || $this->_bInputFromFile) ? TRUE : FALSE);
                break;
            case "output":
                return $this->_bOutputFromFile;
            case "input":
                return $this->_bInputFromFile;
            default:
                return false;
        }
    }

    /* End dceModFileEdit (c)2009-2012 www.dceonline.de */

    private function _createModuleStruct() {
        $bDone = FALSE;
        if ($this->_aModFileEditConf['use'] == TRUE && is_writable($this->_sModPath)) {
            $bDone = TRUE;
            foreach ($this->_aModDefaultStruct as $sFolder) {
                $bDone = $bDone && mkdir($this->_sModPath . $sFolder);
            }
        }
        $this->_createModulePhpFiles();
        umask($this->_oldumask);
        return $bDone;
    }

    private function _createModulePhpFiles() {
        $sPath = $this->_sModPath . "php/";
        $aFileTpl = array(
            'output' => "<?php\n\n?>",
            'input' => "?><?php\n\n?><?php"
        );

        if (is_writable($sPath)) {
            $sOutputFile = $sPath . $this->_sModAlias . "_output.php";
            $sInputFile = $sPath . $this->_sModAlias . "_input.php";
            if (!file_exists($sOutputFile)) {
                $rFileHandler = fopen($sOutputFile, "w");
                if (is_resource($rFileHandler)) {
                    if ($this->getField('output') == "") {
                        fwrite($rFileHandler, $aFileTpl['output']);
                    } else {
                        fwrite($rFileHandler, $this->getField('output'));
                    }
                    fclose($rFileHandler);
                }
            }
            if (!file_exists($sInputFile)) {
                $rFileHandler = fopen($sInputFile, "w");
                if (is_resource($rFileHandler)) {
                    if ($this->getField('input') == "") {
                        fwrite($rFileHandler, $aFileTpl['input']);
                    } else {
                        fwrite($rFileHandler, $this->getField('input'));
                    }
                    fclose($rFileHandler);
                }
            }
        }
    }

}

// end class

class cApiModuleTranslationCollection extends ItemCollection {

    protected $_error;
    
    protected $f_obj;

    /**
     * Constructor Function
     * @param none
     */
    public function __construct() {
        global $cfg;
        parent::__construct($cfg["tab"]["mod_translations"], "idmodtranslation");
        $this->_setItemClass("cApiModuleTranslation");
    }

    /**
     * Creates a new module translation item
     */
    public function create($idmod, $idlang, $original, $translation = false) {
        // Check if the original already exists. If it does,
        // update the translation if passed
        $mod = new cApiModuleTranslation();
        $sorg = $mod->_inFilter($original);

        $this->select("idmod = '$idmod' AND idlang = '$idlang' AND original = '$sorg'");

        if ($item = $this->next()) {
            if ($translation !== false) {
                $item->set("translation", $translation);
                $item->store();
            }
            return $item;
        } else {
            $item = parent::createNewItem();
            $item->set("idmod", $idmod);
            $item->set("idlang", $idlang);
            $item->set("original", $original);
            $item->set("translation", $translation);
            $item->store();
            return $item;
        }
    }

    /**
     * Fetches a translation
     *
     * @param $module int Module ID
     * @param $lang   int Language ID
     * @param $string string String to lookup
     */
    public function fetchTranslation($module, $lang, $string) {
        // If the f_obj does not exist, create one
        if (!is_object($this->f_obj)) {
            $this->f_obj = new cApiModuleTranslation();
        }

        // Create original string
        $sorg = $this->_itemClassInstance->_inFilter($string);

        // Look up
        $this->select("idmod = '$module' AND idlang='$lang' AND original = '$sorg'");

        if ($t = $this->next()) {
            $translation = $t->get("translation");

            if ($translation != "") {
                return $translation;
            } else {
                return $string;
            }
        } else {
            return $string;
        }
    }

    public function import($idmod, $idlang, $file) {
        global $_mImport;

        $parser = new XmlParser("ISO-8859-1");

        $parser->setEventHandlers(array("/module/translation/string/original" => "cHandler_ItemName",
            "/module/translation/string/translation" => "cHandler_Translation"));

        $_mImport["current_item_area"] = "current"; // Pre-specification, as this won't be set from the XML file (here)

        if ($parser->parseFile($file)) {
            foreach ($_mImport["translations"]["current"] as $sOriginal => $sTranslation) {
                $this->create($idmod, $idlang, $sOriginal, $sTranslation);
            }

            return true;
        } else {
            $this->_error = $parser->error;
            return false;
        }
    }

    /**
     * Exports the specified module strings to a file
     *
     * @param $idmod    int Module ID
     * @param $idlang   int Language ID
     * @param $filename string Filename to return
     * @param $return    boolean if false, the result is immediately sent to the browser
     */
    public function export($idmod, $idlang, $filename, $return = false) {
        $langobj = new cApiLanguage($idlang);

        #$langstring = $langobj->get("name") . ' ('.$idlang.')';

        $translations = new cApiModuleTranslationCollection;
        $translations->select("idmod = '$idmod' AND idlang='$idlang'");

        $tree = new XmlTree('1.0', 'ISO-8859-1');
        $root = & $tree->addRoot('module');

        $translation = & $root->appendChild('translation');
        $translation->setNodeAttribs(array("origin-language-id" => $idlang,
            "origin-language-name" => $langobj->get("name")));

        while ($otranslation = $translations->next()) {
            $string = &$translation->appendChild("string");

            $string->appendChild("original", clHtmlSpecialChars($otranslation->get("original")));
            $string->appendChild("translation", clHtmlSpecialChars($otranslation->get("translation")));
        }

        if ($return == false) {
            header("Content-Type: text/xml");
            header("Etag: " . md5(mt_rand()));
            header("Content-Disposition: attachment;filename=\"$filename\"");
            $tree->dump(false);
        } else {
            return $tree->dump(true);
        }
    }

}

/**
 * Module access class
 */
class cApiModuleTranslation extends Item {

    /**
     * Constructor Function
     * @param $loaditem Item to load
     */
    public function __construct($loaditem = false) {
        global $cfg;
        parent::__construct($cfg["tab"]["mod_translations"], "idmodtranslation");
        if ($loaditem !== false) {
            $this->loadByPrimaryKey($loaditem);
        }
    }

    public function useInFilter($sValue) {
        return $this->_inFilter($sValue);
    }

}

function cHandler_ModuleData($sName, $aAttribs, $sContent) {
    global $_mImport;
    $_mImport["module"][$sName] = $sContent;
}

// The following three functions references all file data (e.g. for css,
// js and template files) and layout data
// Note, that first the type is specified (from the "area" information
// in the xml file).
// Second, filename is specified based on "name" node content.
// Third, file content is stored using type, name and node content.
// You will have to specify individual handler functions, if one of
// the file areas may store additional data (e.g. a description)
function cHandler_ItemArea($sName, $aAttribs, $sContent) {
    global $_mImport;
    $_mImport["current_item_area"] = $sContent;
}

function cHandler_ItemName($sName, $aAttribs, $sContent) {
    global $_mImport;
    $_mImport["current_item_name"] = $sContent;
}

function cHandler_ItemData($sName, $aAttribs, $sContent) {
    global $_mImport;
    $_mImport["items"][$_mImport["current_item_area"]][$_mImport["current_item_name"]][$sName] = $sContent;
}

// Separate language area, as someone may specify "cssfiles" or something
// as language name, funny guy...
function cHandler_Translation($sName, $aAttribs, $sContent) {
    global $_mImport;
    $_mImport["translations"][$_mImport["current_item_area"]][$_mImport["current_item_name"]] = $sContent;
}