1: <?php
   2: /**
   3:  * This file contains the module handler class.
   4:  * TODO: Rework comments of this class.
   5:  *
   6:  * @package Core
   7:  * @subpackage Backend
   8:  * @version SVN Revision $Rev:$
   9:  *
  10:  * @author Rusmir Jusufovic
  11:  * @copyright four for business AG <www.4fb.de>
  12:  * @license http://www.contenido.org/license/LIZENZ.txt
  13:  * @link http://www.4fb.de
  14:  * @link http://www.contenido.org
  15:  */
  16: 
  17: defined('CON_FRAMEWORK') || die('Illegal call: Missing framework initialization - request aborted.');
  18: 
  19: /**
  20:  * Class for new modul structere.
  21:  * Saves the Modul-Input in a file (input.php)
  22:  * and
  23:  * Modul-Output in a file(output.php).
  24:  * All moduls of a clients are in [frontend]/modules/.
  25:  *
  26:  * @package Core
  27:  * @subpackage Backend
  28:  */
  29: class cModuleHandler {
  30: 
  31:     /**
  32:      * Path to a modul dir
  33:      *
  34:      * @var string
  35:      */
  36:     private $_modulePath;
  37: 
  38:     /**
  39:      * Path to the modul dir where are all the moduls of a client (frontendpath)
  40:      *
  41:      * @var string
  42:      */
  43:     private $_path;
  44: 
  45:     /**
  46:      * Id of the Modul
  47:      *
  48:      * @var int
  49:      */
  50:     protected $_idmod = NULL;
  51: 
  52:     /**
  53:      * The name of the modul
  54:      *
  55:      * @var string
  56:      */
  57:     private $_moduleName = NULL;
  58: 
  59:     /**
  60:      * Description of the modul.
  61:      *
  62:      * @var string
  63:      */
  64:     protected $_description;
  65: 
  66:     /**
  67:      * The type of the modul.
  68:      *
  69:      * @var string
  70:      */
  71:     protected $_type;
  72: 
  73:     /**
  74:      * The aliac name of the modul
  75:      *
  76:      * @var string
  77:      */
  78:     protected $_moduleAlias;
  79: 
  80:     /**
  81:      * The names of the modul directories.
  82:      *
  83:      * @var array
  84:      */
  85:     protected $_directories = array(
  86:         'css' => 'css/',
  87:         'js' => 'js/',
  88:         'template' => 'template/',
  89:         'image' => 'image/',
  90:         'lang' => 'lang/',
  91:         'php' => 'php/'
  92:     );
  93: 
  94:     /**
  95:      * CONTENIDO cfg
  96:      *
  97:      * @var array
  98:      */
  99:     protected $_cfg = NULL;
 100: 
 101:     /**
 102:      * Contenido cfgClient
 103:      *
 104:      * @var array
 105:      */
 106:     protected $_cfgClient = NULL;
 107: 
 108:     /**
 109:      * id of the Client
 110:      *
 111:      * @var int
 112:      */
 113:     protected $_client = '0';
 114: 
 115:     /**
 116:      * The code of the modul input
 117:      *
 118:      * @var string
 119:      */
 120:     protected $_input = '';
 121: 
 122:     /**
 123:      * The code of the modul output
 124:      *
 125:      * @var string
 126:      */
 127:     protected $_output = '';
 128: 
 129:     /**
 130:      * Encoding oft the site
 131:      *
 132:      * @var string
 133:      */
 134:     protected $_encoding = '';
 135: 
 136:     /**
 137:      * Which format of encoding should be files (input/output/translation...)
 138:      * getEffectiveSetting('encoding', 'file_encoding', 'UTF-8')
 139:      *
 140:      * @var string
 141:      */
 142:     protected $_fileEncoding = '';
 143: 
 144:     /**
 145:      * The id of the lang
 146:      *
 147:      * @var int
 148:      */
 149:     protected $_idlang = -1;
 150: 
 151:     /**
 152:      *
 153:      * @var cDb
 154:      */
 155:     private $_db = NULL;
 156: 
 157:     /**
 158:      *
 159:      * @var array
 160:      */
 161:     protected static $_encodingStore = array();
 162: 
 163:     /**
 164:      * Construct for the class cModuleHandler.
 165:      * With this class you can
 166:      * make a new Modul, rename a Modul. You can save a Output from Modul and
 167:      * Input in a
 168:      * file. The save rules are [Modulname] (is uneque) the files input and
 169:      * output will be named
 170:      * [Modulname]_input.php , [Modulname]_output.php
 171:      *
 172:      * @param int $idmod the id of the modul
 173:      * @throws cException if the module directory can not be created
 174:      */
 175:     public function __construct($idmod = NULL) {
 176:         global $cfg, $cfgClient, $lang, $client;
 177:         $this->_cfg = $cfg;
 178:         $this->_client = $client;
 179:         $this->_cfgClient = $cfgClient;
 180:         $this->_idlang = $lang;
 181:         $this->_encoding = self::getEncoding();
 182:         $this->_fileEncoding = getEffectiveSetting('encoding', 'file_encoding', 'UTF-8');
 183: 
 184:         $this->_db = cRegistry::getDb();
 185: 
 186:         $this->_idmod = $idmod;
 187: 
 188:         $this->_initByModule($idmod);
 189: 
 190:         if ($this->_makeModuleDirectory() == false) {
 191:             throw new cException('Can not create main module directory.');
 192:         }
 193:     }
 194: 
 195:     public static function getEncoding($overrideLanguageId = 0) {
 196:         $lang = cRegistry::getLanguageId();
 197: 
 198:         if ((int) $overrideLanguageId != 0) {
 199:             $lang = $overrideLanguageId;
 200:         }
 201: 
 202:         if ((int) $lang == 0) {
 203:             $clientId = cRegistry::getClientId();
 204: 
 205:             $clientsLangColl = new cApiClientLanguageCollection();
 206:             $clientLanguages = $clientsLangColl->getLanguagesByClient($clientId);
 207:             sort($clientLanguages);
 208: 
 209:             if (isset($clientLanguages[0]) && (int) $clientLanguages[0] != 0) {
 210:                 $lang = $clientLanguages[0];
 211:             }
 212:         }
 213: 
 214:         if (!isset(self::$_encodingStore[$lang])) {
 215:             $cApiLanguage = new cApiLanguage($lang);
 216:             self::$_encodingStore[$lang] = $cApiLanguage->get('encoding');
 217:         }
 218: 
 219:         return self::$_encodingStore[$lang];
 220:     }
 221: 
 222:     /**
 223:      * Exist the modulname in directory
 224:      *
 225:      * @param string $name
 226:      * @param array $cfgClient
 227:      */
 228:     public function modulePathExistsInDirectory($name) {
 229:         return is_dir($this->_cfgClient[$this->_client]['module']['path'] . $name . '/');
 230:     }
 231: 
 232:     /**
 233:      * Save a content in the file, use for css/js
 234:      *
 235:      * @param string $frontendPath
 236:      * @param string $templateName
 237:      * @param string $fileType
 238:      * @param string $fileContent
 239:      * @return bool string
 240:      */
 241:     public function saveContentToFile($templateName, $fileType, $fileContent, $saveDirectory = 'cache') {
 242:         $sSaveDirectory = $this->_cfgClient[$this->_client]['path']['frontend'] . $saveDirectory . '/';
 243:         if (!is_dir($sSaveDirectory)) {
 244:             return false;
 245:         }
 246: 
 247:         $templateName = str_replace(' ', '_', $templateName);
 248:         $templateName = strtolower($templateName);
 249:         $fileOperation = cFileHandler::write($sSaveDirectory . $templateName . '.' . $fileType, $fileContent);
 250:         if ($fileOperation === false) {
 251:             return false;
 252:         }
 253:         $url = $this->_cfgClient[$this->_client]['path']['htmlpath'] . $saveDirectory . '/' . $templateName . '.' . $fileType;
 254: 
 255:         // Remove protocol so CSS & JS can be displayed for HTTPS too!
 256:         $url = str_replace('http://', '//', $url);
 257: 
 258:         return $url;
 259:     }
 260: 
 261:     /**
 262:      * Get the cleaned name
 263:      *
 264:      * @param string $name mod name
 265:      * @param string $defaultChar default character
 266:      */
 267:     public static function getCleanName($name, $defaultChar = '_') {
 268:         // the first character of modul/Layut name should be [a-zA-Z0-9]|_|-
 269:         $name = cApiStrCleanURLCharacters($name);
 270:         // get the first charcte
 271:         $firstChar = substr($name, 0, 1);
 272:         if (!preg_match('/^[a-zA-Z0-9]|_|-$/', $firstChar)) {
 273:             // replace the first character
 274:             $name = $defaultChar . substr($name, 1);
 275:         }
 276: 
 277:         return $name;
 278:     }
 279: 
 280:     /**
 281:      * Init the vars of the class.
 282:      *
 283:      * @param array $modulData
 284:      *            [idmod],[name],[input],[output],[forntedpath],[client]
 285:      */
 286:     public function initWithDatabaseRow($db) {
 287:         if (is_object($db)) {
 288:             $this->_initByModule($db->f('idmod'));
 289:         }
 290:     }
 291: 
 292:     /**
 293:      * Init the vars of the class, make a query to the Db
 294:      *
 295:      * @param int $idmod the id of the modul
 296:      */
 297:     protected function _initByModule($idmod = NULL) {
 298:         if ((int) $idmod == 0) {
 299:             return;
 300:         }
 301: 
 302:         $cApiModule = new cApiModule($idmod);
 303: 
 304:         if ($cApiModule->virgin == false) {
 305:             $this->_idmod = $idmod;
 306:             $this->_client = $cApiModule->get('idclient');
 307:             $this->_description = $cApiModule->get('description');
 308:             $this->_type = $cApiModule->get('type');
 309:             $this->_input = '';
 310:             $this->_output = '';
 311: 
 312:             $this->_moduleAlias = $cApiModule->get('alias');
 313:             $this->_moduleName = $cApiModule->get('name');
 314:             $this->_path = $this->_cfgClient[$this->_client]['module']['path'];
 315:             $this->_modulePath = $this->_path . $this->_moduleAlias . '/';
 316:         }
 317:     }
 318: 
 319:     /**
 320:      * Get the Modul Path also cms path + module + module name.
 321:      *
 322:      * @return string
 323:      */
 324:     public function getModulePath() {
 325:         return $this->_modulePath;
 326:     }
 327: 
 328:     /**
 329:      * Get the template path.
 330:      * If file is set it will
 331:      * return the complete paht + file
 332:      *
 333:      * @param string $file
 334:      * @return string
 335:      */
 336:     public function getTemplatePath($file = '') {
 337:         return $this->_modulePath . $this->_directories['template'] . $file;
 338:     }
 339: 
 340:     /**
 341:      * Get the css path of the modul
 342:      *
 343:      * @return string
 344:      */
 345:     public function getCssPath() {
 346:         return $this->_modulePath . $this->_directories['css'];
 347:     }
 348: 
 349:     /**
 350:      * Get the php path of the modul
 351:      *
 352:      * @return string
 353:      */
 354:     public function getPhpPath() {
 355:         return $this->_modulePath . $this->_directories['php'];
 356:     }
 357: 
 358:     /**
 359:      * Get the js path of the modul
 360:      *
 361:      * @return string
 362:      */
 363:     public function getJsPath() {
 364:         return $this->_modulePath . $this->_directories['js'];
 365:     }
 366: 
 367:     /**
 368:      * Get the main css file modulenam.css
 369:      *
 370:      * @return string
 371:      */
 372:     public function getCssFileName() {
 373:         return $this->_moduleAlias . '.css';
 374:     }
 375: 
 376:     /**
 377:      * Returns random characters
 378:      *
 379:      * @param int $count amount of characters
 380:      * @return string
 381:      */
 382:     protected function getRandomCharacters($count) {
 383:         $micro1 = microtime();
 384:         $rand1 = rand(0, time());
 385:         $rand2 = rand(0, time());
 386:         return substr(md5($micro1 . $rand1 . $rand2), 0, $count);
 387:     }
 388: 
 389:     /**
 390:      * Check if exist a file
 391:      *
 392:      * @param string $type js | template | css the directory of the file
 393:      * @param string $fileName file name
 394:      */
 395:     public function existFile($type, $fileName) {
 396:         return cFileHandler::exists($this->_modulePath . $this->_directories[$type] . $fileName);
 397:     }
 398: 
 399:     /**
 400:      * Delete file
 401:      *
 402:      * @param string $type js |template | css directory of the file
 403:      * @param string $fileName file name
 404:      */
 405:     public function deleteFile($type, $fileName) {
 406:         if ($this->existFile($type, $fileName)) {
 407:             return unlink($this->_modulePath . $this->_directories[$type] . $fileName);
 408:         } else {
 409:             return false;
 410:         }
 411:     }
 412: 
 413:     /**
 414:      * Make and save new file
 415:      *
 416:      * @param string $type css | js | template directory of the file
 417:      * @param string $fileName file name
 418:      * @param string $content content of the file
 419:      */
 420:     public function createModuleFile($type, $fileName = NULL, $content = '') {
 421:         // make directory if not exist
 422:         if (!$this->createModuleDirectory($type)) {
 423:             return false;
 424:         }
 425: 
 426:         // if not set use default filename
 427:         if ($fileName == NULL || $fileName == '') {
 428:             $fileName = $this->_moduleAlias;
 429: 
 430:             if ($type == 'template') {
 431:                 $fileName = $fileName . '.html';
 432:             } else {
 433:                 $fileName = $fileName . '.' . $type;
 434:             }
 435:         }
 436: 
 437:         // make and save file contents
 438:         if ($type == 'css' || $type == 'js' || $type == 'template') {
 439:             if (!$this->existFile($type, $fileName)) {
 440:                 $content = iconv($this->_encoding, $this->_fileEncoding, $content);
 441:                 if (!$this->isWritable($this->_modulePath . $this->_directories[$type] . $fileName, $this->_modulePath . $this->_directories[$type])) {
 442:                     return false;
 443:                 }
 444: 
 445:                 if (cFileHandler::write($this->_modulePath . $this->_directories[$type] . $fileName, $content) === false) {
 446:                     $notification = new cGuiNotification();
 447:                     $notification->displayNotification('error', i18n("Can't make file: ") . $fileName);
 448:                     return false;
 449:                 }
 450:             } elseif ($content != '') {
 451:                 $content = iconv($this->_encoding, $this->_fileEncoding, $content);
 452:                 if (!$this->isWritable($this->_modulePath . $this->_directories[$type] . $fileName, $this->_modulePath . $this->_directories[$type])) {
 453:                     return false;
 454:                 }
 455:                 if (cFileHandler::write($this->_modulePath . $this->_directories[$type] . $fileName, $content) === false) {
 456:                     $notification = new cGuiNotification();
 457:                     $notification->displayNotification('error', i18n("Can't make file: ") . $fileName);
 458:                     return false;
 459:                 }
 460:             }
 461:         } else {
 462:             return false;
 463:         }
 464: 
 465:         return true;
 466:     }
 467: 
 468:     /**
 469:      * Rename a file
 470:      *
 471:      * @param string $type css | js | template directory of the file
 472:      * @param string $oldFileName old name of the file
 473:      * @param string $newFileName the new name of the file
 474:      * @return boolean by success return true
 475:      */
 476:     public function renameModuleFile($type, $oldFileName, $newFileName) {
 477:         if ($this->existFile($type, $newFileName)) {
 478:             return false;
 479:         }
 480: 
 481:         if (!$this->existFile($type, $oldFileName)) {
 482:             return false;
 483:         }
 484: 
 485:         return rename($this->_modulePath . $this->_directories[$type] . $oldFileName, $this->_modulePath . $this->_directories[$type] . $newFileName);
 486:     }
 487: 
 488:     /**
 489:      * Get the name of the main js file (modulname.js)
 490:      *
 491:      * @return string the name of the js file
 492:      */
 493:     public function getJsFileName() {
 494:         return $this->_moduleAlias . '.js';
 495:     }
 496: 
 497:     /**
 498:      * Get the content of file, modul js or css or template or php
 499:      *
 500:      * @param string $directory where in module should we look
 501:      * @param string $fileTyp css or js
 502:      */
 503:     public function getFilesContent($directory, $fileTyp, $fileName = NULL) {
 504:         if ($fileName == NULL) {
 505:             $fileName = $this->_moduleAlias . '.' . $fileTyp;
 506:         }
 507: 
 508:         if ($this->existFile($directory, $fileName)) {
 509:             $content = cFileHandler::read($this->_modulePath . $this->_directories[$directory] . $fileName);
 510:             $content = iconv($this->_fileEncoding, $this->_encoding . '//IGNORE', $content);
 511:             return $content;
 512:         }
 513: 
 514:         return false;
 515:     }
 516: 
 517:     /**
 518:      * Make main module directory.
 519:      *
 520:      * @return boolean
 521:      */
 522:     protected function _makeModuleDirectory() {
 523:         // Do not display error on login page
 524:         if ((int) $this->_client == 0) {
 525:             return true;
 526:         }
 527: 
 528:         $sMainModuleDirectory = $this->_cfgClient[$this->_client]['module']['path'];
 529: 
 530:         // make
 531:         if (!is_dir($sMainModuleDirectory) && $sMainModuleDirectory != NULL) {
 532:             if (mkdir($sMainModuleDirectory, 0777, true) == false) {
 533:                 return false;
 534:             } else {
 535:                 cDirHandler::setDefaultDirPerms($sMainModuleDirectory);
 536:             }
 537:         }
 538: 
 539:         return true;
 540:     }
 541: 
 542:     /**
 543:      * Get all files from a module directory
 544:      *
 545:      * @param string $moduleDirectory template css or js...
 546:      * @return array
 547:      */
 548:     public function getAllFilesFromDirectory($moduleDirectory) {
 549:         $dir = $this->_modulePath . $this->_directories[$moduleDirectory];
 550:         return cDirHandler::read($dir);
 551:     }
 552: 
 553:     /**
 554:      * Set the new modul name.
 555:      *
 556:      * @var $name string
 557:      */
 558:     public function changeModuleName($name) {
 559:         $this->_moduleAlias = $name;
 560:         $this->_modulePath = $this->_path . $this->_moduleAlias . '/';
 561:     }
 562: 
 563:     /**
 564:      * Removes this module from the filesystem.
 565:      * Also deletes the version files.
 566:      *
 567:      * @return bool true on success or false on failure
 568:      */
 569:     public function eraseModule() {
 570:         // Delete modules only if we find info.xml at module path
 571:         if (cFileHandler::exists($this->_modulePath . 'info.xml')) {
 572:             return cDirHandler::recursiveRmdir($this->_modulePath);
 573:         } else {
 574:             return false;
 575:         }
 576:     }
 577: 
 578:     /**
 579:      * Read the input of the file _input.php
 580:      *
 581:      * @return string Contents of the Module file (_input.php)
 582:      */
 583:     public function readInput($issource = false) {
 584:         if (cFileHandler::exists($this->_modulePath . $this->_directories['php'] . $this->_moduleAlias . '_input.php') == false) {
 585:             return false;
 586:         }
 587: 
 588:         $content = cFileHandler::read($this->_modulePath . $this->_directories['php'] . $this->_moduleAlias . '_input.php');
 589: 
 590:         if ($issource == true) {
 591:             $content = conHtmlentities($content);
 592:         }
 593: 
 594:         return iconv($this->_fileEncoding, $this->_encoding . '//IGNORE', $content);
 595:     }
 596: 
 597:     /**
 598:      * Read the output of the file _output.php
 599:      *
 600:      * @return string Contents of the Module file( _output.php)
 601:      */
 602:     public function readOutput($issource = false) {
 603:         if (cFileHandler::exists($this->_modulePath . $this->_directories['php'] . $this->_moduleAlias . '_output.php') == false) {
 604:             return false;
 605:         }
 606: 
 607:         $content = cFileHandler::read($this->_modulePath . $this->_directories['php'] . $this->_moduleAlias . '_output.php');
 608: 
 609:         if ($issource == true) {
 610:             $content = conHtmlentities($content);
 611:         }
 612: 
 613:         return iconv($this->_fileEncoding, $this->_encoding . '//IGNORE', $content);
 614:     }
 615: 
 616:     /**
 617:      * Make a directory template/css/image/js/php if not exist
 618:      *
 619:      * @param string $type
 620:      */
 621:     protected function createModuleDirectory($type) {
 622:         if (array_key_exists($type, $this->_directories)) {
 623:             if (!is_dir($this->_modulePath . $this->_directories[$type])) {
 624:                 if (@mkdir($this->_modulePath . $this->_directories[$type]) == false) {
 625:                     return false;
 626:                 } else
 627:                     cDirHandler::setDefaultDirPerms($this->_modulePath . $this->_directories[$type]);
 628:             } else {
 629:                 return true;
 630:             }
 631:         }
 632: 
 633:         return true;
 634:     }
 635: 
 636:     /**
 637:      * Can write/create a file
 638:      *
 639:      * @param string $fileName file name
 640:      * @param string $directory directory where is the file
 641:      * @return bool, success true else false
 642:      */
 643:     public function isWritable($fileName, $directory) {
 644:         if (cFileHandler::exists($fileName)) {
 645:             if (!is_writable($fileName)) {
 646:                 return false;
 647:             }
 648:         } else {
 649:             if (!is_writable($directory)) {
 650:                 return false;
 651:             }
 652:         }
 653:         return true;
 654:     }
 655: 
 656:     /**
 657:      * Check write permissions for this module
 658:      *
 659:      * @param string $type php oder template
 660:      * @return boolean true or false
 661:      */
 662:     public function moduleWriteable($type) {
 663:         if (!cFileHandler::writeable($this->_modulePath . $this->_directories[$type])) {
 664:             return false;
 665:         } else {
 666:             return true;
 667:         }
 668:     }
 669: 
 670:     /**
 671:      * Save a string into the file (_output.php).
 672:      *
 673:      * @param string
 674:      * @return bool if the action (save contents into the file _output.php is
 675:      *         success) return true else false
 676:      */
 677:     public function saveOutput($output = NULL) {
 678:         $fileName = $this->_modulePath . $this->_directories['php'] . $this->_moduleAlias . '_output.php';
 679: 
 680:         if (!$this->createModuleDirectory('php') || !$this->isWritable($fileName, $this->_modulePath . $this->_directories['php'])) {
 681:             return false;
 682:         }
 683: 
 684:         if ($output == NULL) {
 685:             $output = $this->_output;
 686:         }
 687: 
 688:         $output = iconv($this->_encoding, $this->_fileEncoding, $output);
 689: 
 690:         $fileOperation = cFileHandler::write($fileName, $output);
 691: 
 692:         if ($fileOperation === false) {
 693:             return false; // return false if file_put_contents dont work
 694:         } else {
 695:             cFileHandler::setDefaultFilePerms($fileName);
 696:             return true; // return true if file_put_contents working
 697:         }
 698:     }
 699: 
 700:     /**
 701:      * Save a string into the file (_input.php)
 702:      *
 703:      * @param string
 704:      * @return bool if the action (save contents into the file _input.php is
 705:      *         success) return true else false
 706:      */
 707:     public function saveInput($input = NULL) {
 708:         $fileName = $this->_modulePath . $this->_directories['php'] . $this->_moduleAlias . '_input.php';
 709: 
 710:         if (!$this->createModuleDirectory('php') || !$this->isWritable($fileName, $this->_modulePath . $this->_directories['php'])) {
 711:             return false;
 712:         }
 713: 
 714:         if ($input == NULL) {
 715:             $input = $this->_input;
 716:         }
 717: 
 718:         $input = iconv($this->_encoding, $this->_fileEncoding, $input);
 719: 
 720:         $fileOperation = cFileHandler::write($fileName, $input);
 721: 
 722:         if ($fileOperation === false) {
 723:             return false; // return false if file_put_contents dont work
 724:         } else {
 725:             cFileHandler::setDefaultFilePerms($fileName);
 726:             return true; // return true if file_put_contents working
 727:         }
 728:     }
 729: 
 730:     /**
 731:      * This method save a xml file with modul information.
 732:      * If the params not set, get the value from this
 733:      *
 734:      * @param string $moduleName name of the modul
 735:      * @param string $description description of the modul
 736:      * @param string $type type of the modul
 737:      * @return true if success else false
 738:      */
 739:     public function saveInfoXML($moduleName = NULL, $description = NULL, $type = NULL, $alias = NULL) {
 740:         if ($moduleName == NULL) {
 741:             $moduleName = $this->_moduleName;
 742:         }
 743: 
 744:         if ($description == NULL) {
 745:             $description = $this->_description;
 746:         }
 747: 
 748:         if ($type == NULL) {
 749:             $type = $this->_type;
 750:         }
 751: 
 752:         if ($alias == NULL) {
 753:             $alias = $this->_moduleAlias;
 754:         }
 755: 
 756:         $oWriter = new cXmlWriter();
 757:         $oRootElement = $oWriter->addElement('module', '', NULL);
 758: 
 759:         $oWriter->addElement('name', conHtmlSpecialChars($moduleName), $oRootElement);
 760:         $oWriter->addElement('description', conHtmlSpecialChars($description), $oRootElement);
 761:         $oWriter->addElement('type', conHtmlSpecialChars($type), $oRootElement);
 762:         $oWriter->addElement('alias', conHtmlSpecialChars($alias), $oRootElement);
 763: 
 764:         return $oWriter->saveToFile($this->_modulePath, 'info.xml');
 765:     }
 766: 
 767:     /**
 768:      * Make a new module into the modul dir.
 769:      * The modul name will be [ModulName] example
 770:      * Contact_Form or GoogleMaps2.
 771:      *
 772:      * @return bool if modul exist or mkdir and saveInput and saveOutput success
 773:      *         return true.
 774:      *         Else if the mkdir or saveInput or saveOutput not success return
 775:      *         false.
 776:      */
 777:     public function createModule($input = '', $output = '') {
 778:         if ($input != '') {
 779:             $this->_input = $input;
 780:         }
 781: 
 782:         if ($output != '') {
 783:             $this->_output = $output;
 784:         }
 785: 
 786:         if ($this->modulePathExists()) {
 787:             return true;
 788:         }
 789: 
 790:         if (mkdir($this->_modulePath) == false) {
 791:             return false;
 792:         } else {
 793:             cDirHandler::setDefaultDirPerms($this->_modulePath);
 794:         }
 795: 
 796:         // make others directorys
 797:         foreach ($this->_directories as $directory) {
 798:             if (!is_dir($this->_modulePath . $directory)) {
 799:                 if (mkdir($this->_modulePath . $directory) == false) {
 800:                     return false;
 801:                 } else {
 802:                     cDirHandler::setDefaultDirPerms($this->_modulePath . $directory);
 803:                 }
 804:             }
 805:         }
 806: 
 807:         // could not save the info xml
 808:         if ($this->saveInfoXML() == false) {
 809:             return false;
 810:         }
 811: 
 812:         // Save empty strings into the modul files, if someone trying to read
 813:         // contents bevore save into the files
 814:         $retInput = $this->saveInput();
 815:         $retOutput = $this->saveOutput();
 816: 
 817:         if ($retInput == false || $retOutput == false) {
 818:             return false;
 819:         }
 820: 
 821:         return true;
 822:     }
 823: 
 824:     /**
 825:      * Rename a modul and the input and output files.
 826:      *
 827:      * @param string $old old name of the modul
 828:      * @param string $new new name of the modul
 829:      *
 830:      * @return bool true if success
 831:      */
 832:     public function renameModul($old, $new) {
 833:         // try to rename the dir
 834:         if (rename($this->_path . $old, $this->_path . $new) == false) {
 835:             return false;
 836:         } else {
 837:             $retInput = true;
 838:             $retOutput = true;
 839: 
 840:             // if file input exist rename it
 841:             if (cFileHandler::exists($this->_path . $new . '/' . $this->_directories['php'] . $old . '_input.php'))
 842:                 $retInput = rename($this->_path . $new . '/' . $this->_directories['php'] . $old . '_input.php', $this->_path . $new . '/' . $this->_directories['php'] . $new . '_input.php');
 843: 
 844:                 // if file output exist rename it
 845:             if (cFileHandler::exists($this->_path . $new . '/' . $this->_directories['php'] . $old . '_output.php'))
 846:                 $retOutput = rename($this->_path . $new . '/' . $this->_directories['php'] . $old . '_output.php', $this->_path . $new . '/' . $this->_directories['php'] . $new . '_output.php');
 847: 
 848:                 // rename the css file
 849:             if (cFileHandler::exists($this->_path . $new . '/' . $this->_directories['css'] . $old . '.css'))
 850:                 rename($this->_path . $new . '/' . $this->_directories['css'] . $old . '.css', $this->_path . $new . '/' . $this->_directories['css'] . $new . '.css');
 851: 
 852:                 // rename the javascript file
 853:             if (cFileHandler::exists($this->_path . $new . '/' . $this->_directories['js'] . $old . '.js'))
 854:                 rename($this->_path . $new . '/' . $this->_directories['js'] . $old . '.js', $this->_path . $new . '/' . $this->_directories['js'] . $new . '.js');
 855: 
 856:                 // rename the template file
 857:             if (cFileHandler::exists($this->_path . $new . '/' . $this->_directories['template'] . $old . '.html'))
 858:                 rename($this->_path . $new . '/' . $this->_directories['template'] . $old . '.html', $this->_path . $new . '/' . $this->_directories['template'] . $new . '.html');
 859: 
 860:             if ($retInput == true && $retOutput == true) {
 861:                 return true;
 862:             } else {
 863:                 return false;
 864:             }
 865:         }
 866:     }
 867: 
 868:     /**
 869:      * Show if the Modul with the modul name exist in modul dir.
 870:      *
 871:      * return bool if the modul exist return true, else false
 872:      */
 873:     public function modulePathExists() {
 874:         return is_dir($this->_modulePath);
 875:     }
 876: 
 877:     /*
 878:      * Test input code
 879:      *
 880:      * @return array (bool state, string errorMessage)
 881:      */
 882:     public function testInput() {
 883: 
 884:         return $this->_testCode('input');
 885: 
 886:     }
 887: 
 888:     /*
 889:      * Test output code
 890:      *
 891:      * @return array (bool state, string errorMessage)
 892:      */
 893:     public function testOutput() {
 894: 
 895:         return $this->_testCode('output');
 896: 
 897:     }
 898: 
 899:     /*
 900:      * Test module code
 901:      *
 902:      * @param $inputType string code field type
 903:      *
 904:      * @return array (bool state, string errorMessage)
 905:      */
 906:     protected function _testCode($inputType) {
 907: 
 908:         $result = array(
 909:             'state' => false,
 910:             'errorMessage' => 'Module path not exist'
 911:         );
 912: 
 913:         if (!$this->modulePathExists()) return $result;
 914: 
 915:         $module  = new cApiModule($this->_idmod);
 916:         $isError = 'none';
 917: 
 918:         //Set code as error before checking, if fatal exist
 919:         switch ($module->get("error")) {
 920:             case 'none';
 921:             $toCheck = $inputType;
 922:             break;
 923:             case 'input';
 924:             if ($inputType == 'output') $toCheck = 'both';
 925:             break;
 926:             case 'output';
 927:             if ($inputType == 'input') $toCheck = 'both';
 928:             break;
 929:             case 'both';
 930: 
 931:             break;
 932:         }
 933:         if ($toCheck !== $module->get("error")) {
 934:             $module->set("error", $toCheck);
 935:             $module->store();
 936:         }
 937: 
 938:         //check code
 939:         switch($inputType) {
 940:             case 'input':
 941: 
 942:                 $code       = $this->readInput();
 943:                 $result = $this->_verifyCode($code, $this->_idmod . "i");
 944:                 if ($result['state'] !== true) $isError = 'input';
 945: 
 946:                 break;
 947:             case 'output':
 948: 
 949:                 $code       = $this->readOutput();
 950:                 $result = $this->_verifyCode($code, $this->_idmod . "o", true);
 951:                 if ($result['state'] !== true) $isError = 'output';
 952: 
 953:                 break;
 954:         }
 955: 
 956:         //update error value for input and output
 957:         switch ($module->get("error")) {
 958:             case 'none';
 959: 
 960:             break;
 961:             case 'input';
 962:             if ($isError == 'none' && $inputType == 'output') $isError = 'input';
 963:             if ($isError == 'output') $isError = 'both';
 964:             break;
 965:             case 'output';
 966:             if ($isError == 'none' && $inputType == 'input') $isError = 'output';
 967:             if ($isError == 'input') $isError = 'both';
 968:             break;
 969:             case 'both';
 970:             if ($isError == 'none' && $inputType == 'input') $isError = 'output';
 971:             if ($isError == 'none' && $inputType == 'output') $isError = 'input';
 972:             break;
 973:         }
 974: 
 975:         //Store error information in the database (to avoid re-eval for module
 976:         //overview/menu)
 977:         if ($isError !== $module->get("error")) {
 978:             $module->set("error", $isError);
 979:             $module->store();
 980:         }
 981: 
 982:         return $result;
 983: 
 984:     }
 985: 
 986:     /**
 987:      * Check module php code
 988:      *
 989:      * @param string $code Code to evaluate
 990:      * @param string $id Unique ID for the test function
 991:      * @param string $mode true if start in php mode, otherwise false
 992:      *
 993:      * @return array (bool state, string errorMessage)
 994:      */
 995:     protected function _verifyCode($code, $id, $output = false) {
 996: 
 997:         $result = array(
 998:             'state' => false,
 999:             'errorMessage' => NULL
1000:         );
1001: 
1002:         // Put a $ in front of all CMS variables to prevent PHP error messages
1003:         $sql = 'SELECT type FROM ' . $this->_cfg['tab']['type'];
1004:         $this->_db->query($sql);
1005:         while ($this->_db->nextRecord()) {
1006:             $code = str_replace($this->_db->f('type') . '[', '$' . $this->_db->f('type') . '[', $code);
1007:         }
1008: 
1009:         $code = preg_replace(',\[(\d+)?CMS_VALUE\[(\d+)\](\d+)?\],i', '[\1\2\3]', $code);
1010:         $code = str_replace('CMS_VALUE', '$CMS_VALUE', $code);
1011:         $code = str_replace('CMS_VAR', '$CMS_VAR', $code);
1012: 
1013:         // If the module is an output module, escape PHP since all output modules
1014:         // enter php mode
1015:         if ($output == true) {
1016:             $code = "?>\n" . $code . "\n<?php";
1017:         }
1018: 
1019:         // Looks ugly: Paste a function declarator in front of the code
1020:         $code = 'function foo' . $id . ' () {' . $code;
1021:         $code .= "\n}\n";
1022: 
1023:         // To parse the error message, we prepend and append a phperror tag in front
1024:         // of the output
1025:         $sErs = ini_get('error_prepend_string'); // Save current setting (see below)
1026:         $sEas = ini_get('error_append_string'); // Save current setting (see below)
1027:         @ini_set('error_prepend_string', '<phperror>');
1028:         @ini_set('error_append_string', '</phperror>');
1029: 
1030:         // Turn off output buffering and error reporting, eval the code
1031:         ob_start();
1032:         $display_errors = ini_get('display_errors');
1033:         @ini_set('display_errors', true);
1034:         $output = eval($code);
1035:         @ini_set('display_errors', $display_errors);
1036: 
1037:         // Get the buffer contents and turn it on again
1038:         $output = ob_get_contents();
1039:         ob_end_clean();
1040: 
1041:         // Remove the prepend and append settings
1042:         /*
1043:          * 19.09.2006: Following lines have been disabled, as ini_restore has been
1044:          * disabled by some hosters as there is a security leak in PHP (PHP <= 5.1.6
1045:          * & <= 4.4.4)
1046:          */
1047:         // ini_restore('error_prepend_string');
1048:         // ini_restore('error_append_string');
1049:         @ini_set('error_prepend_string', $sErs); // Restoring settings (see above)
1050:         @ini_set('error_append_string', $sEas); // Restoring settings (see above)
1051: 
1052:         // Strip out the error message
1053:         $isError = strpos($output, '<phperror>');
1054: 
1055:         // More stripping: Users shouldnt see where the file is located, but they
1056:         // should see the error line
1057:         if ($isError !== false) {
1058: 
1059:             $pattern         = '/(<phperror>|<\/phperror>|<b>|<\/b>|<br>|<br \/>)/im';
1060:             $modErrorMessage = trim(preg_replace($pattern, '', $output));
1061:             $errorPart1      = substr($modErrorMessage, 0, strpos($modErrorMessage, ' in '));
1062:             $errorPart2      = substr($modErrorMessage, strpos($modErrorMessage, ' on line '));
1063:             $modErrorMessage = $errorPart1 . $errorPart2;
1064:             $result['errorMessage'] = sprintf(i18n("Error in module. Error location: %s"), $modErrorMessage);
1065: 
1066:         }
1067: 
1068:         // Check if there are any php short tags in code, and display error
1069:         $bHasShortTags = false;
1070:         if (preg_match('/<\?\s+/', $code)) {
1071:             $bHasShortTags = true;
1072:             $result['errorMessage'] = i18n('Please do not use short open tags. (Use <?php instead of <?).');
1073:         }
1074: 
1075:         // Now, check if the magic value is 941. If not, the function didn't compile
1076:         if ($bHasShortTags || $isError !== false) {
1077:             $result['state'] = false;
1078:         } else {
1079:             $result['state'] = true;
1080:         }
1081: 
1082:         return $result;
1083: 
1084:     }
1085: 
1086: }