/**
* 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'));
}
