/** * Traitement par défaut */ public function processDefault() { // On charge la classe exportée Copix::RequireOnce($this->_exportClassFilename); // Définition du serveur Soap if (isset($this->_wsname)) { $server = new SoapServer(_url('wsserver|default|wsdl', array('wsname' => $this->_wsname))); } else { $server = new SoapServer(_url('wsserver|default|wsdl')); } // Assignation de la classe exportée au serveur $server->setclass($this->_exportClass); // Traitement des appels if ($_SERVER['REQUEST_METHOD'] == 'POST') { $server->handle(); return _arNone(); } else { $res = '<strong>' . _i18n('wsserver.handle.title') . '</strong>'; $res .= '<ul>'; foreach ($server->getFunctions() as $func) { $res .= '<li>' . $func . '</li>'; } $res .= '</ul>'; $res; } $tpl = new CopixTpl(); $tpl->assign('MAIN', $res); return new CopixActionReturn(CopixActionReturn::DISPLAY, $tpl); }
public function testInclusion() { // Copix::RequireClass ('CopixListenerFactory'); $this->assertTrue(class_exists('CopixListenerFactory')); // Copix::RequireClass ('CopixFile'); $this->assertTrue(class_exists('CopixFile')); // Copix::RequireClass ('CopixTimer'); $this->assertTrue(class_exists('CopixTimer')); // Copix::RequireClass ('CopixEMailer'); $this->assertTrue(class_exists('CopixEMailer')); // Copix::RequireClass ('CopixErrorObject'); $this->assertTrue(class_exists('CopixErrorObject')); // Copix::RequireClass ('CopixFormFactory'); $this->assertTrue(class_exists('CopixFormFactory')); // Copix::RequireClass ('CopixDateTime'); $this->assertTrue(class_exists('CopixDateTime')); // Copix::RequireClass ('CopixUser'); $this->assertTrue(class_exists('CopixUser')); // Copix::RequireClass ('CopixI18NBundle'); $this->assertTrue(class_exists('CopixI18NBundle')); // Copix::RequireClass ('CopixHTTPHeader'); $this->assertTrue(class_exists('CopixHTTPHeader')); // Copix::RequireClass ('CopixFilter'); $this->assertTrue(class_exists('CopixFilter')); // Copix::RequireClass ('CopixMimeTypes'); $this->assertTrue(class_exists('CopixMimeTypes')); try { $this->assertFalse(Copix::RequireClass('SomeFooClass')); $this->fail(); //Un exception aurait du être générée } catch (Exception $e) { $this->assertTrue(true); } }
/** * Création d'une instance d'un objet service * @param Object $pServiceDescription un objet qui décrit les composantes du service (avec les propriétés module, service, methode) */ private static function _create($pServiceDescription, $pParams = array()) { $serviceID = $pServiceDescription->module . '|' . $pServiceDescription->service; $execPath = CopixModule::getPath($pServiceDescription->module); $fileName = $execPath . COPIX_CLASSES_DIR . strtolower(strtolower($pServiceDescription->service)) . '.services.php'; if (!Copix::RequireOnce($fileName)) { throw new CopixServicesException('Cannot load service from ' . $fileName); } //Nom des objets/méthodes à utiliser. $objName = 'Services' . $pServiceDescription->service; return new $objName($pParams); }
/** * Creation d'un objet zone d'identifiant $pName * @param string $name le nom de la zone à instancier. * @private */ private static function _create($pName) { //Récupération des éléments critiques. $fileInfo = new CopixModuleFileSelector($pName); CopixContext::push($fileInfo->module); //Récupère le nom du fichier en fonction du module courant. $fileName = $fileInfo->getPath(COPIX_ZONES_DIR) . strtolower($fileInfo->fileName) . '.zone.php'; if (!file_exists($fileName)) { return false; } //inclusion du fichier. Copix::RequireOnce($fileName); $objName = 'Zone' . $fileInfo->fileName; return new $objName(); }
/** * Construction du controller * @param string $configFile chemin du fichier de configuration du projet */ public function __construct($configFile) { self::$_instance = $this; // creating CopixConfig Object and includes the asked configuration file. $config = CopixConfig::instance(); require $configFile; if ($config->copixerrorhandler_enabled) { Copix::setErrorHandler(new CopixErrorHandler($config)); } CopixRequest::setRequest(array_merge(array('module' => 'default', 'group' => 'default', 'action' => 'default'), CopixUrl::parse(CopixUrl::getRequestedPathInfo(), false, true))); // do what we need for each plugin before starting the session $this->_beforeSessionStart(); if ($config->sessionName != null) { session_name($config->sessionName); } session_start(); $config->afterSessionStart(); }
/** * Charge la définition d'une classe. * * @param string $pClassId Sélecteur de classe. * @param boolean $pForceLoad Si vrai, force l'inclusion du fichier même si la classe existe. * @param boolean $pStrict Si vrai, lance une exception si quelque chose se passe mal. * @return mixed Le nom de la classe du sélecteur ou false si l'inclusion n'a pas fonctionné. * @throws CopixException si $pStrict est vrai que l'on a pas pu charger le fichier ou que la classe n'existe pas. */ private static function _loadClass($pClassId, $pForceLoad = false, $pStrict = true, $pSelector = null) { if ($pSelector === null) { $file = CopixSelectorFactory::create($pClassId); } else { $file = $pSelector; } $className = $file->fileName; $filePath = $file->getPath() . COPIX_CLASSES_DIR . $className . '.class.php'; if ($pForceLoad || !class_exists($className, false)) { if (!Copix::RequireOnce($filePath) && $pStrict) { throw new CopixException(_i18n('copix:copix.error.class.couldNotLoadClass', $pClassId)); } } if ($pStrict && !class_exists($className, true)) { throw new CopixException(_i18n('copix:copix.error.class.undefinedClass', $pClassId)); } return $className; }
/** * Assigne le chemin vers le fichier PHP à utiliser et à surcharger pour générer le DAO * @param string $pFilePath le chemin absolu vers le fichier PHP à utiliser * @param string $pRecordName le nom de la classe PHP qui est définie par l'utilisateur pour reprsenter l'enregistrement * @param string $pDAOName le nom de la classe PHP qui est définie par l'utilisateur pour représenter le DAO */ public function setPHPClassFilePath($pFilePath, $pRecordName = null, $pDAOName = null) { if (Copix::RequireOnce($this->_phpClassFilePath = $pFilePath)) { //On s'occupe de récupérer le nom du Record à utiliser si besoin if ($pRecordName !== null) { if (!class_exists($pRecordName)) { throw new Exception('Demande d utilisation de ' . $pRecordName . ' pour le record mais la classe n est pas définie dans le fichier ' . $pFilePath); } else { $this->_userDefinedDAORecordName = $pRecordName; } } else { //on utilise le nom par défaut if (class_exists($daoRecordName = CopixDAOFactory::getDAORecordName($this->_DAOId, false))) { $this->_userDefinedDAORecordName = $daoRecordName; } } //On s'occupe de récupérer le nom du DAO à utiliser si besoin if ($pDAOName !== null) { if (!class_exists($pRecordName)) { throw new Exception('Demande d utilisation de ' . $pDAOName . ' pour le DAO mais la classe n est pas définie dans le fichier ' . $pFilePath); } else { $this->_userDefinedDAOName = $pDAOName; } } else { //on utilise le nom par défaut if (class_exists($daoName = CopixDAOFactory::getDAOName($this->_DAOId, false))) { $this->_userDefinedDAOName = $daoName; } } } else { throw new Exception('impossible de charger le fichier de définition demandé pour le DAO ' . $pFilePath); } }
private static function _getDrivers($pGetOnlyAvailables) { $arDrivers = array(); $arAvailable = array(); if ($dir = @opendir(COPIX_PATH . 'db/drivers/')) { while (false !== ($file = readdir($dir))) { if (is_dir(COPIX_PATH . 'db/drivers/' . $file)) { if (file_exists($fileName = COPIX_PATH . 'db/drivers/' . $file . '/CopixDbConnection.' . $file . '.class.php')) { if ($pGetOnlyAvailables) { Copix::RequireOnce($fileName); $class = 'CopixDbConnection' . $file; if (class_exists($class)) { if (call_user_func(array($class, 'isAvailable'))) { $arAvailable[$file] = $file; } } } else { $arAvailable[$file] = $file; } } } } closedir($dir); } clearstatcache(); return $arAvailable; }
/** Méthode d'autoloading spécifique. * * Essaie de charger une classe selon les informations de $this->potentialClassPaths. * Cela permet de résoudre les dépendances lors de la phase de chargement des fichiers. * * @param string $pClassName Nom de la classe à charger. * * @see $this->potentialClassPaths */ public function autoload($pClassName) { $className = strtolower($pClassName); if (isset($this->potentialClassPaths[$className])) { $files = $this->potentialClassPaths[$className]; unset($this->potentialClassPaths[$className]); foreach ($files as $file) { Copix::RequireOnce($file); if (class_exists($pClassName, false)) { return true; } } } return false; }
* @package copix * @subpackage ldap * @author Croes Gérald * @copyright 2001-2006 CopixTeam * @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file */ /** * @ignore */ if (!defined('COPIX_LDAP_PATH')) { define('COPIX_LDAP_PATH', dirname(__FILE__) . '/'); } Copix::RequireOnce(COPIX_LDAP_PATH . 'CopixLdapConnection.class.php'); Copix::RequireOnce(COPIX_LDAP_PATH . 'CopixLdapResultSet.class.php'); Copix::RequireOnce(COPIX_LDAP_PATH . 'CopixLdapProfil.class.php'); Copix::RequireOnce(COPIX_LDAP_PATH . 'CopixLdapEntry.class.php'); /** * Factory pour acceder aux annuaires ldap * @package copix * @subpackage ldap */ class CopixLdapFactory { /** * Récupèration d'une connection. * @static * @param string $named nom du profil de connection définie dans CopixLdap.plugin.conf.php * @return CopixLdapConnection objet de connection vers l'annuaire ldap */ public function getConnection($named = null) {
/** * Plugin smarty type fonction * Fonction pour déclarer en JS une méthode pour récupérer un element "Ajax" * <code> * {ajax_gethttpobject_declare} * </code> * @see CopixTagLibAjaxGetHttpObject */ function smarty_function_ajax_gethttpobject_declare($params, &$me) { Copix::RequireOnce(COPIX_PATH . 'taglib/CopixTagLibAjaxGetHttpObject.class.php'); CopixTagLibAjaxGetHttpObject::doDeclare(); }
/** * Récupère l'instance de l'actiongroup donné. * * @param object $pActionGroupDescription Description de l'actiongroup dont on souhaite récupérer l'instance. Doit avoir 2 propriétés : module et actiongroup * @return CopixActionGroup * @throws Exception */ public static function instance($pActionGroupDescription) { $actionGroupID = $pActionGroupDescription->module . '|' . $pActionGroupDescription->actiongroup; if (!isset(self::$_instances[$actionGroupID])) { $execPath = CopixModule::getPath($pActionGroupDescription->module); $fileName = $execPath . COPIX_ACTIONGROUP_DIR . strtolower(strtolower($pActionGroupDescription->actiongroup)) . '.actiongroup.php'; if (!Copix::RequireOnce($fileName)) { throw new Exception(_i18n('copix:copix.error.load.actiongroup', $fileName)); } // nom des objets/méthodes à utiliser. $objName = 'ActionGroup' . $pActionGroupDescription->actiongroup; self::$_instances[$actionGroupID] = new $objName(); } return self::$_instances[$actionGroupID]; }
/** * Charge la configuration par défaut d'un plugin. * * Cette méthode est surtout destinée à être appelée depuis les fichiers de configuration réels. * * @param string $pluginName Sélecteur du plugin. */ public static function requireDefaultConfig($pluginName) { Copix::RequireOnce(self::_getDefaultConfigPath($pluginName)); }
/** * Initialise un objet htmlMimeMail pour l'envoi. * * @return htmlMimeMail */ private function _createMailer() { Copix::RequireOnce(COPIX_PATH . '../htmlMimeMail/htmlMimeMail.php'); $mail = new htmlMimeMail(); $mail->setReturnPath(CopixConfig::get('|mailFrom')); $mail->setFrom('"' . CopixConfig::get('|mailFromName') . '" <' . CopixConfig::get('|mailFrom') . '>'); $mail->setHeader('X-Mailer', 'COPIX (http://copix.org) with HTML Mime mail class (http://www.phpguru.org)'); if (CopixConfig::get('|mailMethod') == 'smtp') { $auth = CopixConfig::get('|mailSmtpAuth') == '' ? null : CopixConfig::get('|mailSmtpAuth'); $pass = CopixConfig::get('|mailSmtpPass') == '' ? null : CopixConfig::get('|mailSmtpPass'); $hasAuth = $auth != null; $port = CopixConfig::exists('|mailSmtpPort') && CopixConfig::get('|mailSmtpPort') ? CopixConfig::get('|mailSmtpPort') : null; $mail->setSMTPParams(CopixConfig::get('|mailSmtpHost'), $port, null, $hasAuth, $auth, $pass); } return $mail; }
/** * Création d'un listener * @param string $pModule le nom du module auquel appartient le listener que l'on souhaite créer * @param string $pListenerName le nom du listener * @return CopixListener */ private function _create($pModule, $pListenerName) { if (!isset($this->_listenersSingleton[$pModule][$pListenerName])) { Copix::RequireOnce(CopixModule::getPath($pModule) . '/' . COPIX_CLASSES_DIR . strtolower($pListenerName) . '.listener.php'); $className = 'Listener' . $pListenerName; $this->_listenersSingleton[$pModule][$pListenerName] = new $className(); } return $this->_listenersSingleton[$pModule][$pListenerName]; }
/** * Création d'un objet capable de créer la définition d'une DAO en fonction de son identifiant. * * @param string $pFullyQualifiedDAO l'identifiant du DAO dont on souhaites récupérer la définition * @param string $pConnectionName le nom de la connexion à utiliser pour créer le DAO */ private static function _getDAODefinitionBuilder($pFullyQualifiedDAO, $pConnectionName) { Copix::RequireOnce(COPIX_PATH . 'dao/CopixDAODefinitionBuilder.class.php'); $selector = CopixSelectorFactory::create($pFullyQualifiedDAO); $fileName = $selector->getPath(COPIX_RESOURCES_DIR) . strtolower($selector->fileName . '.dao.xml'); $fileClassName = $selector->getPath(COPIX_CLASSES_DIR) . strtolower($selector->fileName . '.dao.php'); if (is_readable($fileName) || count(explode('|', $pFullyQualifiedDAO)) > 1 || count(explode(':', $pFullyQualifiedDAO)) > 1) { //On lit si il existe un element parameterdans la definition du xml if (!($parsedFile = simplexml_load_file($fileName))) { throw new Exception('Impossible d\'analyser (1) le fichier XML pour le DAO ' . $fileName); } if (isset($parsedFile->parameter) && $parsedFile->parameter['value'] == 'auto') { return new CopixDAODefinitionXmlAutoBuilder($pFullyQualifiedDAO, array('xmlFilePath' => $fileName, 'phpClassFilePath' => $fileClassName, 'connection' => $pConnectionName)); } return new CopixDAODefinitionXmlBuilder($pFullyQualifiedDAO, array('xmlFilePath' => $fileName, 'phpClassFilePath' => $fileClassName, 'connection' => $pConnectionName)); } else { return new CopixDAODefinitionDBBuilder($pFullyQualifiedDAO, array('tableName' => $pFullyQualifiedDAO, 'phpClassFilePath' => $fileClassName, 'connection' => $pConnectionName)); } }
/** * Force une reconstruction du fichier COPIX_CLASSPATHS_FILE * * @see CopixClassPathBuilder */ public function rebuildClassPath() { Copix::RequireOnce(COPIX_UTILS_PATH . 'CopixClassPathBuilder.class.php'); $builder = new CopixClassPathBuilder(); $builder->build(); }
/** * Chargeur de classe. * * @param string $pClassName Nom de la classe à charger. * @return boolean */ public static function autoload($pClassName) { if (!isset(self::$_globalReferences[$pClassName]) || !self::$_globalReferences[$pClassName]) { return false; } list($type, $fileName) = self::$_globalReferences[$pClassName]; switch ($type) { case self::DAO: return _daoInclude($fileName) ? true : false; case self::MODULE_CLASS: return _classInclude($fileName) ? true : false; case self::FILE: return Copix::RequireOnce($fileName) ? true : false; } return false; }
/** * Création de la classe capable d'interpretter les url pour un module donné * @param string $pModule le nom du module dont on veut l'interpretteur * @return object */ private static function _createModuleHandler($pModule) { if (array_key_exists($pModule, self::$_handlers)) { return self::$_handlers[$pModule]; } if (file_exists($filePath = self::_getModuleHandlerFileName($pModule))) { Copix::RequireOnce($filePath); $className = 'UrlHandler' . $pModule; return self::$_handlers[$pModule] = new $className(); } else { return self::$_handlers[$pModule] = null; } }
/** * Appel d'une balise "PHP" située dans utils/copix/taglib/ * @param string $tagName le nom de la balise que l'on souhaites lancer * @param mixed $pParams les paramètres qui ont étés envoyés à la balise * @param array of mixed tableau des paramètres à envoyer à la balise */ public static function tag($pTagName, $pParams = array(), $pContent = null) { Copix::RequireOnce(COPIX_PATH . 'taglib/' . $pTagName . '.templatetag.php'); $className = 'TemplateTag' . $pTagName; $tag = new $className($pTagName); $tag->setParams($pParams); return $tag->process($pParams, $pContent); }
/** * Cette fonction retourne l'instance de la stratégie adéquat * * @param String $pProfil nom du profil configurer dans copixConfig * @param String $pLevel niveau du log demandé * @return stratégie qui convient */ private static function _getStrategy($pClasse) { $pClasse = strtolower($pClasse); if ($pClasse == '') { throw new Exception('Pas de stratégie définie'); } if (isset(self::$_strategy[$pClasse])) { return self::$_strategy[$pClasse]; } switch ($pClasse) { case 'file': Copix::RequireOnce(COPIX_PATH . 'log/CopixLogFileStrategy.class.php'); return self::$_strategy[$pClasse] = new CopixLogFileStrategy(); case 'db': Copix::RequireOnce(COPIX_PATH . 'log/CopixLogDbStrategy.class.php'); return self::$_strategy[$pClasse] = new CopixLogDbStrategy(); case 'system': Copix::RequireOnce(COPIX_PATH . 'log/CopixLogSystemStrategy.class.php'); return self::$_strategy[$pClasse] = new CopixLogSystemStrategy(); case 'session': Copix::RequireOnce(COPIX_PATH . 'log/CopixLogSessionStrategy.class.php'); return self::$_strategy[$pClasse] = new CopixLogSessionStrategy(); case 'firebug': Copix::RequireOnce(COPIX_PATH . 'log/CopixLogFirebugStrategy.class.php'); return self::$_strategy[$pClasse] = new CopixLogFireBugStrategy(); case 'page': Copix::RequireOnce(COPIX_PATH . 'log/CopixLogPageStrategy.class.php'); return self::$_strategy[$pClasse] = new CopixLogPageStrategy(); case 'email': Copix::RequireOnce(COPIX_PATH . 'log/CopixLogEmailStrategy.class.php'); return self::$_strategy[$pClasse] = new CopixLogEmailStrategy(); default: return self::$_strategy[$pClasse] = _ioClass($pClasse); } }
/** * Met en place un nouveau gestionnaire d'erreur. * * @param ICopixErrorHandler $pErrorHandler Nouveau gestionnaire d'erreur. */ public static function setErrorHandler(ICopixErrorHandler $pErrorHandler) { self::$_errorHandler = $pErrorHandler; set_error_handler(array($pErrorHandler, 'handle')); }