/**
* Récupère le flux RSS à partir d'une URL.
* Utilise MagpieRss http://magpierss.sourceforge.net/
*/
public function getRss($url, $nbMax = -1)
{
$arFeeds = array();
// Test and Create rss temp_dir
$cachePath = COPIX_CACHE_PATH . 'fluxrss/';
$cacheTestFile = 'rss.txt';
if (!file_exists($cachePath . $cacheTestFile)) {
require_once COPIX_UTILS_PATH . 'CopixFile.class.php';
$objectWriter = new CopixFile();
$objectWriter->write($cachePath . $cacheTestFile, date('Y/m/d H:i'));
}
// Use Magpie to parse current RSS file
define('MAGPIE_CACHE_DIR', COPIX_CACHE_PATH . 'rss');
require_once 'rss_fetch.inc';
$rss = fetch_rss($url);
if ($rss) {
if ($nbMax > 0) {
$arFeeds = array_slice($rss->items, 0, intval($nbMax));
} else {
$arFeeds = $rss->items;
}
}
foreach ($arFeeds as $key => $Feed) {
//print_r($Feed);
if (isset($Feed['dc']['date'])) {
$currentDate = @parse_w3cdtf($Feed['dc']['date']);
// Ok with dotclear that uses w3c date format
//var_dump($currentDate);
} else {
$currentDate = -1;
}
if ($currentDate != -1) {
$Feed['dc']['datecopix'] = date("Ymd", $currentDate);
if (!isset($Feed['date_timestamp'])) {
$Feed['date_timestamp'] = $currentDate;
}
} else {
if (isset($Feed['date_timestamp'])) {
// Ok with b2evolution that uses timestamp format
$Feed['dc']['datecopix'] = date('Ymd', $Feed['date_timestamp']);
} else {
$Feed['dc']['datecopix'] = null;
$Feed['date_timestamp'] = null;
}
}
//var_dump($Feed);
//die();
$arFeeds[$key] = $Feed;
}
return $arFeeds;
}
/**
* Indique si le fichier de configuration est modifiable
* @return boolean
*/
public function isWritable()
{
if (!file_exists($this->getPath())) {
return CopixFile::write($this->getPath(), '<?php $_log_profiles = array (); ?>');
}
return is_writable($this->getPath());
}
/**
* Set the data mode
* @param string $dataset_name
* @param strong $mode "static" or "db"
*/
public function setDataMode($mode = "static", $dataset = null, $connectionName = null)
{
if (empty($dataset) && $mode == "db") {
throw new Exception("No dataset given for CopixBayesian datas used with database");
}
$this->dataset = "bayesiantable_" . $dataset;
$this->mode = $mode == "db" ? "db" : "static";
//get tables
if ($this->mode == "db") {
$this->connectionName = $connectionName;
$ct = CopixDB::getConnection($connectionName);
if (!in_array($this->dataset, $ct->getTableList())) {
if ($ct instanceof CopixDBConnectionMySQL || $ct instanceof CopixDBConnectionPDO_MySQL) {
$sql = CopixFile::read(dirname(__FILE__) . "/../install/template_scripts/install.pdo_mysql.sql");
} elseif ($ct instanceof CopixDBConnectionPDO_SQLite) {
$sql = CopixFile::read(dirname(__FILE__) . "/../install/template_scripts/install.pdo_sqlite.sql");
} elseif ($ct instanceof CopixDBConnectionPDO_PgSQL) {
$sql = CopixFile::read(dirname(__FILE__) . "/../install/template_scripts/install.pdo_pgsql.sql");
} else {
//throw new CopixException("Data type: ".get_class($ct)." not currently supported");
}
$sql = str_replace('%TABLENAME%', $this->dataset, $sql);
_doQuery($sql, array(), $connectionName);
}
}
}
/**
* Indique si le fichier de configuration est modifiable
* @return boolean
*/
public function isWritable()
{
if (!file_exists($this->getPath())) {
return CopixFile::write($this->getPath(), '<?php $_' . $this->_handlerType . '_handlers = array (); ?>');
}
return is_writable($this->getPath());
}
/**
* Rendu HTML de l'élément
*
* @return unknown
*/
public function render()
{
$path = COPIX_CACHE_PATH . "/graphviz/";
CopixFile::createDir($path);
$md5 = md5(stripslashes($this->code));
$this->hash = $md5;
$file = $md5 . ".png";
if (!file_exists($path . $file)) {
$this->_render($file);
}
return $file;
}
public function testSimpleRTFTemplate()
{
$template = CopixClassesFactory::create('genericTools|RTFTemplate');
$template->assign('VARIABLE_1', 'Voici une belle présentation <b>avec des infos importantes</b> ', true);
$template->assign('VARIABLE_2', '<ul><li>puce 1</li><li>puce 2</li><li>puce 3</li></ul>', true);
$template->assign('VARIABLE_3', 'Contenu simple', true);
$codeDuDocumentRTFFinal = $template->fetch('generictools|rtftest.rtf');
$selector = CopixSelectorFactory::create('generictools|rtftest.expectedresult.rtf');
$expectedResultFilePath = $selector->getPath(COPIX_TEMPLATES_DIR) . $selector->fileName;
$codeDuDocumentRTFTest = file_get_contents($expectedResultFilePath);
CopixFile::write('/tmp/document_sortie.rtf', $codeDuDocumentRTFFinal);
$this->assertEquals($codeDuDocumentRTFFinal, $codeDuDocumentRTFTest);
}
public function testOtherFunctions()
{
$this->assertEquals(CopixFile::extractFileExt('file.ext'), '.ext');
$this->assertEquals(CopixFile::extractFileExt('filenoext'), null);
$this->assertEquals(CopixFile::extractFileName('/chemin/pour/geraldc/'), 'geraldc');
}
/**
* Génération du DAO
* @param string $pFullyQualifiedDAO l'identifiant du DAO complet
*/
private static function _generateDAO($pFullyQualifiedDAO, $pConnectionName)
{
Copix::RequireOnce(COPIX_PATH . 'dao/CopixDAOGenerator.class.php');
$generator = new CopixDAOGenerator(self::_getDAODefinitionBuilder($pFullyQualifiedDAO, $pConnectionName)->getDefinition());
// génération des classes PHP correspondant à la définition de la DAO
CopixFile::write(CopixDAOFactory::_getCompiledPath($pFullyQualifiedDAO), $generator->getPHPCode());
}
/**
* Extrait des informations de l'ensemble des fichiers module.xml des modules installés.
*
* @param string $pCacheKey Clef pour la mise en cache.
* @param string $pXPath Expression XPath de sélection des
* @param callback $pParserCallback
* @return mixed La valeur retournée par $pParserCallback.
*/
public static function getParsedModuleInformation($pCacheKey, $pXPath, $pParserCallback)
{
if (!is_callable($pParserCallback)) {
$final = '';
if (is_array($pParserCallback)) {
foreach ($pParserCallback as $name) {
$final .= $name;
}
}
throw new Exception("getParsedModuleInformation: {$final} should be callable");
}
$config = CopixConfig::instance();
$force_compile = $config->force_compile;
$compile_check = $config->compile_check;
//var_dump($force_compile, $compile_check);
if (!isset(self::$_registryCache[$pCacheKey])) {
$cacheFile = self::_getRegistryCacheFile($pCacheKey);
$must_compile = !file_exists($cacheFile) || $force_compile;
if (!$must_compile && $compile_check) {
// Test les fichiers si compile_check est vrai
_log("Vérification du cache pour {$pCacheKey} ({$cacheFile})", "registry", CopixLog::NOTICE);
$cacheDate = filemtime($cacheFile);
foreach (self::getList(true) as $moduleName) {
$descriptorPath = self::getPath($moduleName) . 'module.xml';
if (filemtime($descriptorPath) > $cacheDate) {
_log("{$descriptorPath} est plus récent que {$cacheFile}", "registry", CopixLog::NOTICE);
$must_compile = true;
break;
}
}
}
if ($must_compile) {
_log("Génération du cache pour {$pCacheKey} ({$cacheFile})", "registry", CopixLog::NOTICE);
// Liste les modules
$nodes = array();
foreach (self::getList(true) as $moduleName) {
$xml = simplexml_load_file(self::getPath($moduleName) . 'module.xml');
// Extrait les infos
$moduleNodes = $xml->xpath($pXPath);
// N'ajoute dans la liste que si on trouve quelque chose
if (is_array($moduleNodes) && count($moduleNodes) > 0) {
$nodes[$moduleName] = $xml->xpath($pXPath);
}
}
// Compile le tout
self::$_registryCache[$pCacheKey] = call_user_func($pParserCallback, $nodes);
// Ecrit le cache
CopixFile::write($cacheFile, serialize(self::$_registryCache[$pCacheKey]));
} else {
_log("Chargement du cache pour {$pCacheKey} ({$cacheFile})", "registry", CopixLog::NOTICE);
self::$_registryCache[$pCacheKey] = unserialize(CopixFile::read($cacheFile));
}
}
return self::$_registryCache[$pCacheKey];
}
/**
* Affiche un contenu dans un div et avec des infos sur le fichier appelant
*
* @param string $pContent Contenu à afficher.
*/
private static function _outputFormatted(&$pContent)
{
if (!headers_sent()) {
@header("Content-Type: text/html;charset=UTF-8");
}
echo '<div style="border: solid #CC0000 1px; color: black; padding: 5px; text-align: left; cursor: default; align: left; background-color: white; whitespace: preserve; overflow: auto">';
$caller = self::getCaller();
list($prefix, $file) = CopixFile::getCopixPathPrefix($caller['file']);
if ($prefix) {
$file = $prefix . DIRECTORY_SEPARATOR . $file;
}
echo '<div style="width:100%; background-color:#CC0000; color: white; padding-top: 5px; padding-bottom: 5px; margin-bottom: 5px; font-weight: bold; text-align: center;">';
printf("From %s, line %d :", htmlentities($file), $caller['line']);
echo '</div>';
echo '<pre>';
echo $pContent;
echo '</pre>';
echo '</div>';
}
/**
* Supression des éléments du cache
* Si $pId = null tout le type (ou sous-type) passé en paramètre du constructeur est vidé
*
* @param string $pId Identifiant de l'élément à supprimer
* @param string $pType Type de cache
* @param array $pExtra Paramètres supplémentaires
*/
public function clear($pId, $pType, $pExtra)
{
if ($pId !== null) {
$fileName = $this->_makeFileName($pId, $pType, $pExtra);
if (is_readable($fileName)) {
unlink($this->_makeFileName($pId, $pType, $pExtra));
}
} else {
if (file_exists(COPIX_CACHE_PATH . self::_getDir($pExtra) . $this->_getDirectory($pType, $pExtra))) {
CopixFile::removeDir(COPIX_CACHE_PATH . self::_getDir($pExtra) . $this->_getDirectory($pType, $pExtra) . '/');
}
}
}
/**
* Recherche de templates dans un module et d'extension donnée.
*
* Cette fonction va rechercher les templates dans le répertoire module template par défaut
* et également dans le répertoire de surcharge dans le thème default
* (project/modules/module_name/templates/* & project/themes/default/module_name/*)
*
* <code>
* $arTemplates = CopixTpl::find ('module_name', '.dyn.tpl');
* //recherche de plusieurs types de templates
* $arTemplates = CopixTpl::find ('module_name', array ('.dyn.tpl', '.dyn.ptpl'));
* //recherche avec masques
* $arTemplates = CopixTpl::find ('module_name', '.dyn.*');
* </code>
*
* @param string $pModuleName le nom du module dans lequel on va chercher le template
* @param mixed $pExtension l'extension que l'on recherche (ou un tableau d'extensions)
*
* @return array Retourne un tableau contenant en clé 'modules|fichier_trouvé' et en valeur le nom dans (tpl){*@name NOM} (ptpl)/*@name NOM si aucun nom n'est trouvé, on mets la clé
*/
public static function find($pModuleName, $pExtension)
{
if (!is_array($pExtension)) {
$pExtension = array($pExtension);
}
$files = array();
foreach ($pExtension as $extension) {
$files = array_merge($files, CopixFile::search('*' . $extension, COPIX_PROJECT_PATH . 'themes/default/' . $pModuleName . '/', false));
$files = array_merge($files, CopixFile::search('*' . $extension, CopixModule::getPath($pModuleName) . 'templates/', false));
}
$arFiles = array();
/*TODO Ajouter la gestion des ptpl*/
foreach ($files as $key => $file) {
$name = $pModuleName . '|' . basename($file);
$tpl = CopixFile::read($file);
if (substr($file, strlen($file) - 4) == 'ptpl') {
$nom = ereg_replace('.*\\/*@name ([^\\*]+[^/]+)\\*/.*', '\\1', $tpl);
} else {
$nom = ereg_replace('.*{*@name ([^\\*]+[^}]+)\\*\\}.*', '\\1', $tpl);
}
if (strlen($nom) == strlen($tpl)) {
$nom = $name;
}
$arFiles[$name] = $nom;
}
return $arFiles;
}
/**
* Charge la configuration d'un plugin.
*
* S'il n'existe pas de configuration par défaut, renvoie null. Sinon:
*
* Cherche le fichier de configuration dans var/config/plugins/MODULE/PLUGIN.plugin.conf.php.
* Si le fichier n'existe pas il est crée avec un contenu par défaut.
*
* @param string $pluginName Sélecteur du plugin.
* @return mixed L'objet configuration ou NULL si le plugin n'a pas de configuration.
*/
private static function _loadConfig($pluginName)
{
$fic = new CopixModuleFileSelector($pluginName);
$nom = strtolower($fic->fileName);
$config_class = "PluginConfig" . $fic->fileName;
// Vérifie la présence d'une configuration "old school"
$old_config_path = $fic->getPath(COPIX_PLUGINS_DIR) . $nom . '/' . $nom . '.plugin.conf.php';
if (file_exists($old_config_path)) {
// Ce plugin utilise l'ancien système de configuration
_log($pluginName . " utilise un fichier de configuration dans les sources !", "plugin", CopixLog::WARNING);
Copix::RequireOnce($old_config_path);
$config = new $config_class();
return $config;
}
// Vérifie la présence d'une configuration par défaut
$default_config_path = self::_getDefaultConfigPath($pluginName);
$default_config_class = "PluginDefaultConfig" . $fic->fileName;
if (!file_exists($default_config_path)) {
// Pas de configuration
return null;
}
// Cherche la configuration actuelle
$config_path = $fic->getOverloadedPath(COPIX_VAR_PATH . 'config/plugins/') . $nom . '.plugin.conf.php';
if (!file_exists($config_path)) {
// Génère une configuration par défaut
_log($pluginName . ": création de la configuration par défaut ({$config_path})", "plugin");
CopixFile::write($config_path, "<?php\n" . "CopixPluginRegistry::requireDefaultConfig('{$pluginName}');\n" . "class {$config_class} extends {$default_config_class} {\n" . "\t// Surchargez la configuration ici.\n" . "}\n" . "?>");
}
// Charge la configuration
Copix::RequireOnce($config_path);
$config = new $config_class();
return $config;
}
/**
* Ecriture du code PHP pour les listeners.
* @param array $pEventsInfo Tableau des informations sur les événements (qui écoute quoi)
*/
private function _writePHPCode($pEventsInfos)
{
$generator = new CopixPHPGenerator();
$_resources = $generator->getPHPTags($generator->getVariableDeclaration('$eventList', $pEventsInfos));
//writing the PHP code to the disk
CopixFile::write($this->_compiledFileName(), $_resources);
}
/**
* Traite un fichier de module.
*
* Si le type MIME du fichier est l'un de ceux pour lesquels on procède à la résolution
* de {copixresource}, on vérifie si une version cachée existe.
*
* @param string $pFilePath Chemin complet du ficher.
* @param string $pMIMEType Type MIME du fichier.
* @return string Chemin complet du fichier à envoyer.
*/
private function _processModuleFile($pFilePath, $pMIMEType)
{
// Seuls certains types MIME sont traités
if (!in_array($pMIMEType, self::$_processedMimeTypes)) {
return $pFilePath;
}
// Récupère la config
$config = $this->_getCopixConfig();
// Calcule le chemin du fichier en cache
$cacheKey = array(COPIX_TEMP_PATH . 'resources/');
$cacheKey[] = $this->_module;
$cacheKey[] = $this->_theme;
if ($config->i18n_path_enabled) {
$cacheKey[] = $this->_country;
$cacheKey[] = $this->_lang;
}
$cacheKey[] = preg_replace('@[/\\x5c]@', '_', $this->_path);
$cacheFile = join('_', $cacheKey);
// Vérifie le fichier caché
if ($config->force_compile || !file_exists($cacheFile) || ($config->compile_check || filemtime($pFilePath) > filemtime($cacheFile))) {
// Génère le fichier de cache en remplaçant tous les tags
CopixFile::write($cacheFile, preg_replace_callback('@\\{\\s*copixresource\\s+path=(["\'])(((\\w+)?\\|)?/?(.+))\\1\\s*}@i', array($this, '_replaceCopixresource'), CopixFile::read($pFilePath)));
}
// On envoie le fichier caché
return $cacheFile;
}
/**
* Pour vider le répertoire temp
*
*/
public function clearTemp()
{
CopixFile::removeFileFromPath(COPIX_TEMP_PATH, false, array($this, '_tempFileFilter'));
}
public function uncompress($filename, $path = null)
{
$zip = zip_open($filename);
if ($zip) {
$buf = array();
while ($zip_entry = zip_read($zip)) {
$entry = new _zip_entry();
$entry->name = zip_entry_name($zip_entry);
$entry->realsize = zip_entry_filesize($zip_entry);
$entry->size = zip_entry_compressedsize($zip_entry);
$entry->method = zip_entry_compressionmethod($zip_entry);
if (zip_entry_open($zip, $zip_entry, "r")) {
$entry->buffer = zip_entry_read($zip_entry, $entry->realsize);
zip_entry_close($zip_entry);
$buf[] = $entry;
}
}
zip_close($zip);
}
//return the _zip_zntry struct if not path given to save to...
if (!$path) {
return $buf;
}
//else... uncompress to pathx
foreach ($buf as $file) {
$file->name = "/" . $file->name;
if (!CopixFile::write($path . $file->name, $file->buffer)) {
return false;
}
}
return true;
}
/**
* Loads the resources for a given lang/country.
* will automatically loads the default (lang lang)
* @param string $lang the language
* @param string $country the country
*/
private function _loadLocales($lang, $country)
{
$this->_loadedCountries[] = $country;
//file names for different cases.
$bundleLang = $this->_fic->fileName . '_' . $lang . '.properties';
$bundleCountry = $this->_fic->fileName . '_' . $lang . '_' . $country . '.properties';
$path = $this->_fic->getPath(COPIX_RESOURCES_DIR);
$toLoad[] = array('file' => $path . $this->_fic->fileName . '.properties', 'lang' => 'default', 'country' => 'DEFAULT');
$toLoad[] = array('file' => $path . $bundleLang, 'lang' => $lang, 'country' => strtoupper($lang));
$toLoad[] = array('file' => $path . $bundleCountry, 'lang' => $lang, 'country' => $country);
// check if we have a compiled version of the ressources
$_compileResourceId = $this->_getCompileId($lang, $country);
if (($_compileResourceIdTime = @filemtime($_compileResourceId)) !== false) {
$config = CopixConfig::instance();
if ($config->compile_check || $config->force_compile) {
if ($config->force_compile) {
//force compile, compiled files are never assumed to be ok.
$okcompile = false;
} else {
// on verifie que les fichiers de ressources sont plus anciens que la version compilée
$compiledate = $_compileResourceIdTime;
$okcompile = true;
//Compiled files are assumed to be ok.
foreach ($toLoad as $infos) {
if (($fileTime = @filemtime($infos['file'])) !== false) {
if (!isset($fileTime) || $fileTime > $compiledate) {
$okcompile = false;
break;
}
}
}
}
} else {
//no compile check, it's ok then
$okcompile = true;
}
if ($okcompile) {
$_loaded = array();
include $_compileResourceId;
//va charger _loaded
$this->_messages[$country] = $_loaded;
//everything was loaded.
return;
}
}
//loads the founded resources.
foreach ($toLoad as $infos) {
$this->_loadResources($infos['file'], $country);
}
//we want to use the PHP compilation of the resources.
$generator = new CopixPHPGenerator();
$_resources = $generator->getPHPTags($generator->getVariableDeclaration('$_loaded', isset($this->_messages[$country]) ? $this->_messages[$country] : array()));
CopixFile::write($_compileResourceId, $_resources);
}
/**
* Retourne le bon type MIME en fonction d'un nom de fichier
* @param string $pFileName le nom du fichier à tester
* @return string
*/
public static function getFromFileName($pFileName)
{
return self::getFromExtension(CopixFile::extractFileExt($pFileName));
}
/**
* Sauvegarde la valeur des paramètres dans un fichier PHP
* @return void
*/
private function _writeInPHPCache()
{
$generator = new CopixPHPGenerator();
$_resources = $generator->getPHPTags($generator->getVariableDeclaration('$_load', $this->_values));
CopixFile::write($this->_getCompiledFileName(), $_resources);
}
/**
* Reconstruit le fichier COPIX_CLASSPATHS_FILE.
*
* Nécessite les droits d'écriture dans COPIX_CLASSPATHS_FILE. Cette opération est réservée aux développeurs de Copix.
*/
public function build()
{
// Vérifie qu'on ait ce qu'il faut
if (!is_writable(COPIX_CLASSPATHS_FILE)) {
throw new Exception("Impossible d'écrire dans " . COPIX_CLASSPATHS_FILE);
}
// Récupère la liste des fichiers
$files = CopixFile::findFiles(array_keys($this->basePaths), array($this, '_classFileFilter'), array($this, '_classDirFilter'));
// Effectue une "évaluation" des fichiers pour y trouver des classes/interfaces potentielles
$this->preParse($files);
// Met en place notre autoloader maison
$autoloader = array($this, 'autoload');
spl_autoload_register($autoloader);
// Charge tout
foreach ($files as $file) {
include_once $file;
}
// Supprime l'autoloader maison
spl_autoload_unregister($autoloader);
// Récupère toutes les classes et interfaces
$classes = array_merge(get_declared_classes(), get_declared_interfaces());
// Filtre celles de copix
$classes = array_filter($classes, array($this, '_classNameFilter'));
// Genère le fichier classpath
$classPathCode = "<?php\n";
$classPathCode .= "/** Chemins des classes.\n";
$classPathCode .= " * Ce fichier est généré par CopixClassPathBuilder, ne pas le modifier !\n";
$classPathCode .= " * NE JAMAIS LE SUPPRIMER NON PLUS !\n";
$classPathCode .= " * Dernière génération le " . date("Y-m-d H:i:s") . "\n";
$classPathCode .= "*/\n";
$classPathCode .= " return array(\n";
sort($classes);
foreach ($classes as $class) {
$reflection = new ReflectionClass($class);
$fileName = $reflection->getFileName();
if (isset($this->fileIncludes[$fileName])) {
$classPathCode .= sprintf("\t'%s' => %s,\n", strtolower($class), $this->fileIncludes[$fileName]);
}
}
$classPathCode .= ");\n";
$classPathCode .= "?>";
// Ecrit le fichier
CopixFile::write(COPIX_CLASSPATHS_FILE, $classPathCode);
}
