/**
* 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());
}
/**
* 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());
}
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);
}
/**
* 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;
}
/**
* 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);
}
/**
* Enregistrement des éléments dans le cache
*
* @param string $pId Identifiant de l'élméent à écrire dans le cache
* @param string $pType Type de cache ou écrire
* @param mixed $pContent Contenu
* @param array $pExtra Paramètres supplémentaires
*/
public function write($pId, $pContent, $pType, $pExtra)
{
CopixFile::write($this->_makeFileName($pId, $pType, $pExtra), serialize($pContent));
}
/**
* 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);
}
/**
* 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;
}
/**
* Test de suppression de répertoire
*
*/
public function testRemoveDir()
{
// On écrit un fichier dans une arborescence
CopixFile::write(COPIX_TEMP_PATH . 'unitfiletest/unitfiletest/unitfiletest/abcdef', 'tsetset');
$this->assertTrue(file_exists(COPIX_TEMP_PATH . 'unitfiletest/unitfiletest/unitfiletest/abcdef'));
// On efface le répertoire
CopixFile::removeDir(COPIX_TEMP_PATH . 'unitfiletest');
$this->assertTrue(!file_exists(COPIX_TEMP_PATH . 'unitfiletest/unitfiletest/unitfiletest/abcdef'));
// On écrit un fichier dans une arborescence
CopixFile::write(COPIX_TEMP_PATH . 'unitfiletest/unitfiletest/unitfiletest/abcdef', 'tsetset');
$this->assertTrue(file_exists(COPIX_TEMP_PATH . 'unitfiletest'));
// On efface le contenu du répertoire
CopixFile::removeDir(COPIX_TEMP_PATH . 'unitfiletest/');
$this->assertTrue(count(glob(COPIX_TEMP_PATH . 'unitfiletest/*')) == 0);
CopixFile::removeDir(COPIX_TEMP_PATH . 'unitfiletest');
// On écrit un fichier dans une arborescence
CopixFile::write(COPIX_TEMP_PATH . 'unitfiletest/unitfiletest/unitfiletest/abcdef', 'tsetset');
$this->assertTrue(file_exists(COPIX_TEMP_PATH . 'unitfiletest'));
// On efface le répertoire avec la méthode removeFileFromPath
$this->assertTrue(CopixFile::removeFileFromPath(COPIX_TEMP_PATH . 'unitfiletest/unitfiletest/'));
CopixFile::removeDir(COPIX_TEMP_PATH . 'unitfiletest');
}
/**
* 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];
}
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;
}
/**
* 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);
}
/**
* 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);
}
