function sendMail(ezcMail $mail)
{
$separator = "/";
$mail->appendExcludeHeaders(array('to', 'subject'));
$headers = rtrim($mail->generateHeaders());
// rtrim removes the linebreak at the end, mail doesn't want it.
if (count($mail->to) + count($mail->cc) + count($mail->bcc) < 1) {
throw new ezcMailTransportException('No recipient addresses found in message header.');
}
$additionalParameters = "";
if (isset($mail->returnPath)) {
$additionalParameters = "-f{$mail->returnPath->email}";
}
$sys = eZSys::instance();
$fname = time() . '-' . rand() . '.mail';
$qdir = eZSys::siteDir() . eZSys::varDirectory() . $separator . 'mailq';
$data = $headers . ezcMailTools::lineBreak();
$data .= ezcMailTools::lineBreak();
$data .= $mail->generateBody();
$data = preg_replace('/(\\r\\n|\\r|\\n)/', "\r\n", $data);
$success = eZFile::create($fname, $qdir, $data);
if ($success === false) {
throw new ezcMailTransportException('The email could not be sent by sendmail');
}
}
function sendMail(eZMail $mail)
{
$ini = eZINI::instance();
$sendmailOptions = '';
$emailFrom = $mail->sender();
$emailSender = $emailFrom['email'];
if (!$emailSender || count($emailSender) <= 0) {
$emailSender = $ini->variable('MailSettings', 'EmailSender');
}
if (!$emailSender) {
$emailSender = $ini->variable('MailSettings', 'AdminEmail');
}
if (!eZMail::validate($emailSender)) {
$emailSender = false;
}
$isSafeMode = ini_get('safe_mode');
if ($isSafeMode and $emailSender and $mail->sender() == false) {
$mail->setSenderText($emailSender);
}
$filename = time() . '-' . mt_rand() . '.mail';
$data = preg_replace('/(\\r\\n|\\r|\\n)/', "\r\n", $mail->headerText() . "\n" . $mail->body());
$returnedValue = eZFile::create($filename, 'var/log/mail', $data);
if ($returnedValue === false) {
eZDebug::writeError('An error occurred writing the e-mail file in var/log/mail', __METHOD__);
}
return $returnedValue;
}
public function synchronise(eZSolrBase $collection, $elevateXML, $params)
{
$uri_components = parse_url($collection->SearchServerURI);
// The extra variables are used to avoid PHP strict warnings using end() directly on the preg_split result
$pathElements = preg_split('/\\//', $uri_components['path']);
$collectionName = end($pathElements);
$filename = implode('__', array($uri_components['host'], $uri_components['port'], $collectionName, 'elevate.xml'));
return eZFile::create($filename, $params['base_dir'], $elevateXML);
}
/**
* Regression test for issue 16400
* @link http://issues.ez.no/16400
* @return unknown_type
*/
public function testIssue16400()
{
$className = 'Media test class';
$classIdentifier = 'media_test_class';
$filePath = 'tests/tests/kernel/datatypes/ezmedia/ezmediatype_regression_issue16400.flv';
eZFile::create( $filePath );
$attributeName = 'Media';
$attributeIdentifier = 'media';
$attributeType = 'ezmedia';
//1. test method fetchByContentObjectID
$class = new ezpClass( $className, $classIdentifier, $className );
$class->add( $attributeName, $attributeIdentifier, $attributeType );
$attribute = $class->class->fetchAttributeByIdentifier( $attributeIdentifier );
$attribute->setAttribute( 'can_translate', 0 );
$class->store();
$object = new ezpObject( $classIdentifier, 2 );
$dataMap = $object->object->dataMap();
$fileAttribute = $dataMap[$attributeIdentifier];
$dataType = new eZMediaType();
$dataType->fromString( $fileAttribute, $filePath );
$fileAttribute->store();
$object->publish();
$object->refresh();
//verify fetchByContentObjectID
$mediaObject = eZMedia::fetch( $fileAttribute->attribute( 'id' ), 1 );
$medias = eZMedia::fetchByContentObjectID( $object->object->attribute( 'id' ) );
$this->assertEquals( $mediaObject->attribute( 'filename' ), $medias[0]->attribute( 'filename' ) );
$medias = eZMedia::fetchByContentObjectID( $object->object->attribute( 'id' ),
$fileAttribute->attribute( 'language_code' ) );
$this->assertEquals( $mediaObject->attribute( 'filename' ), $medias[0]->attribute( 'filename' ) );
//2. test issue
// create translation
$contentObject = $object->object;
$storedFileName = $mediaObject->attribute( 'filename' );
$version = $contentObject->createNewVersionIn( 'nor-NO',
$fileAttribute->attribute( 'language_code' ) );
$version->setAttribute( 'status', eZContentObjectVersion::STATUS_INTERNAL_DRAFT );
$version->store();
$version->removeThis();
$sys = eZSys::instance();
$dir = $sys->storageDirectory();
//verify the file is deleted
$storedFilePath = $dir . '/original/video/' . $storedFileName;
$file = eZClusterFileHandler::instance( $storedFilePath );
$this->assertTrue( $file->exists( $storedFilePath ) );
if ( $file->exists( $storedFilePath ) )
unlink( $storedFilePath );
}
private function __construct()
{
$ini_varnish = eZINI::instance('mugo_varnish.ini');
$this->debug = $ini_varnish->variable('VarnishSettings', 'DebugCurl') == 'enabled';
$this->varnishServers = $ini_varnish->variable('VarnishSettings', 'VarnishServers');
// override connection timeout
if ($ini_varnish->variable('VarnishSettings', 'ConnectionTimeout') > -1) {
$this->baseCurlOptions[CURLOPT_CONNECTTIMEOUT] = $ini_varnish->variable('VarnishSettings', 'ConnectionTimeout');
}
// make sure the log file exits
if (!file_exists(self::CURL_DEBUG_OUTPUT_FILE)) {
eZFile::create(self::CURL_DEBUG_OUTPUT_FILE);
}
}
/**
* Import object.
*
* @param Array getParameters.
* @param Array getOptions.
* @param Array postParameters.
* @param Array postOptions.
* @param string Import type.
*
* @return DOMElement DOMElement containing OO document.
*/
protected function importOODocument($getParams, $getOptions, $postParams, $postOptions, $importType = 'import')
{
$nodeID = $postParams['nodeID'];
$data = $postParams['data'];
// Alex 2008/04/22 - Added format argument: 'odt' (default), 'doc'
$format = $postOptions['format'];
$languageCode = $postOptions['languageCode'];
$base64Encoded = $postOptions['base64Encoded'];
$node = eZContentObjectTreeNode::fetch($nodeID, $languageCode);
if (!$node) {
throw new Exception('Could not fetch node: ' . $nodeID);
}
// Decode data.
if ($base64Encoded) {
// Alex 2008/04/16 - Added str_replace()
$data = base64_decode(str_replace(' ', '+', $data));
}
// Store data to temporary file.
// Alex 2008/04/22 - Added format argument: 'odt' (default), 'doc'
$filename = substr(md5(mt_rand()), 0, 8) . ".{$format}";
$tmpFilePath = eZSys::cacheDirectory() . '/ezodf/' . substr(md5(mt_rand()), 0, 8);
$tmpFilename = $tmpFilePath . '/' . $filename;
if (!eZFile::create($filename, $tmpFilePath, $data)) {
throw new Exception('Could not create file: ' . $tmpFilename);
}
$import = new eZOOImport();
$result = $import->import($tmpFilename, $nodeID, $filename, $importType);
eZDir::recursiveDelete($tmpFilePath);
if (!$result) {
throw new Exception('OO import failed: ' . $import->getErrorNumber() . ' - ' . $import->getErrorMessage());
}
$domDocument = new DOMDocument('1.0', 'utf-8');
$importElement = $domDocument->createElement('OOImport');
// Add node info about imported document.
$importElement->appendChild($this->createTreeNodeDOMElement($domDocument, $result['MainNode']));
return $importElement;
}
/**
* store mailitem on filesystem
*
* @todo eZFile::create result
* @return void
*/
private function storeMessageToFilesystem()
{
$mailboxItemId = $this->attribute('id');
$mailboxId = $this->attribute('mailbox_id');
$messageId = $this->attribute('message_id');
$currentTimestamp = time();
// return filepath
$filePathArray = $this->getFilePathArray();
// return content string of mail item
$messageData = $this->MessageString;
// create file in path with content
$createResult = eZFile::create($filePathArray['file_name'], $filePathArray['file_dir'], $messageData);
}
function appendDocument($name, $mimeType = false, $os = false, $audience = false, $create = false, $data = false)
{
if (!$mimeType) {
$mimeType = 'text/plain';
}
$this->Parameters['documents'][] = array('name' => $name, 'mime-type' => $mimeType, 'os' => $os, 'data' => $data, 'audience' => $audience);
if ($create) {
eZFile::create($name, $this->path() . '/' . eZPackage::documentDirectory(), $data);
}
}
/**
* Downloads file.
*
* Sets $this->ErrorMsg in case of an error.
*
* \private
* \param $url URL.
* \param $outDir Directory where to put downloaded file to.
* \param $forcedFileName Force saving downloaded file under this name.
* \return false on error, path to downloaded package otherwise.
*/
function downloadFile($url, $outDir, $forcedFileName = false)
{
$fileName = $outDir . "/" . ($forcedFileName ? $forcedFileName : basename($url));
eZDebug::writeNotice("Downloading file '{$fileName}' from {$url}");
// Create the out directory if not exists.
if (!file_exists($outDir)) {
eZDir::mkdir($outDir, false, true);
}
// First try CURL
if (extension_loaded('curl')) {
$ch = curl_init($url);
$fp = eZStepSiteTypes::fopen($fileName, 'wb');
if ($fp === false) {
$this->ErrorMsg = ezpI18n::tr('design/standard/setup/init', 'Cannot write to file') . ': ' . $this->FileOpenErrorMsg;
return false;
}
curl_setopt($ch, CURLOPT_FILE, $fp);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_FAILONERROR, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
// Get proxy
$ini = eZINI::instance();
$proxy = $ini->hasVariable('ProxySettings', 'ProxyServer') ? $ini->variable('ProxySettings', 'ProxyServer') : false;
if ($proxy) {
curl_setopt($ch, CURLOPT_PROXY, $proxy);
$userName = $ini->hasVariable('ProxySettings', 'User') ? $ini->variable('ProxySettings', 'User') : false;
$password = $ini->hasVariable('ProxySettings', 'Password') ? $ini->variable('ProxySettings', 'Password') : false;
if ($userName) {
curl_setopt($ch, CURLOPT_PROXYUSERPWD, "{$userName}:{$password}");
}
}
if (!curl_exec($ch)) {
$this->ErrorMsg = curl_error($ch);
return false;
}
curl_close($ch);
fclose($fp);
} else {
$parsedUrl = parse_url($url);
$checkIP = isset($parsedUrl['host']) ? ip2long(gethostbyname($parsedUrl['host'])) : false;
if ($checkIP === false) {
return false;
}
// If we don't have CURL installed we used standard fopen urlwrappers
// Note: Could be blocked by not allowing remote calls.
if (!copy($url, $fileName)) {
$buf = eZHTTPTool::sendHTTPRequest($url, 80, false, 'eZ Publish', false);
$header = false;
$body = false;
if (eZHTTPTool::parseHTTPResponse($buf, $header, $body)) {
eZFile::create($fileName, false, $body);
} else {
$this->ErrorMsg = ezpI18n::tr('design/standard/setup/init', 'Failed to copy %url to local file %filename', null, array("%url" => $url, "%filename" => $fileName));
return false;
}
}
}
return $fileName;
}
/**
* Test for the fileStore() method with the delete option
*/
public function testFileStoreWithoutDelete()
{
// create local file on disk
$directory = 'var/tests/' . __FUNCTION__;
$localFile = $directory . '/file.txt';
eZFile::create('file.txt', $directory, md5(time()));
// 1. First store to cluster, with delete option
$ch = eZClusterFileHandler::instance();
$ch->fileStore($localFile, 'test', false, 'text/plain');
// 2. Check that the created file exists
$ch2 = eZClusterFileHandler::instance($localFile);
self::assertTrue($ch2->exists());
if (!$this instanceof eZFSFileHandlerTest) {
self::assertEquals('text/plain', $ch2->metaData['datatype']);
self::assertEquals('test', $ch2->metaData['scope']);
self::assertFileExists($localFile);
}
self::deleteLocalFiles($localFile);
}
/**
* Stores the data in $fileData to the remote and local file and commits the
* transaction.
*
* The parameter $fileData must contain the same as information as the
* $generateCallback returns as explained in processCache().
* @note This method is just a continuation of the code in processCache()
* and is not meant to be called alone since it relies on specific
* state in the database.
*/
public function storeCache($fileData)
{
$scope = false;
$datatype = false;
$binaryData = null;
$fileContent = null;
$store = true;
$storeCache = false;
if (is_array($fileData)) {
if (isset($fileData['scope'])) {
$scope = $fileData['scope'];
}
if (isset($fileData['datatype'])) {
$datatype = $fileData['datatype'];
}
if (isset($fileData['content'])) {
$fileContent = $fileData['content'];
}
if (isset($fileData['binarydata'])) {
$binaryData = $fileData['binarydata'];
}
if (isset($fileData['store'])) {
$store = $fileData['store'];
}
} else {
$binaryData = $fileData;
}
// This checks if we entered timeout and got our generating file stolen
// If this happens, we don't store our cache
if ($store and $this->checkCacheGenerationTimeout()) {
$storeCache = true;
}
$mtime = false;
$result = null;
if ($binaryData === null && $fileContent === null) {
eZDebug::writeError("Write callback need to set the 'content' or 'binarydata' entry for '{$this->filePath}'", __METHOD__);
$this->abortCacheGeneration();
return null;
}
if ($binaryData === null) {
$binaryData = "<" . "?php\n\treturn " . var_export($fileContent, true) . ";\n?" . ">\n";
}
if ($fileContent === null) {
$result = $binaryData;
} else {
$result = $fileContent;
}
if (!$this->filePath) {
return $result;
}
// no store advice from cache generation timeout or disabled viewcache,
// we just return the result
if (!$storeCache) {
eZDebugSetting::writeDebug('kernel-clustering', "Not storing this cache", __METHOD__);
$this->abortCacheGeneration();
return $result;
}
// stale cache handling: we just return the result, no lock has been set
if ($this->useStaleCache) {
eZDebugSetting::writeDebug('kernel-clustering', "Stalecache mode enabled for this cache", "dfs::storeCache( {$this->filePath} )");
// we write the generated cache to disk if it does not exist yet,
// to speed up the next uncached operation
// This file will be overwritten by the real file
clearstatcache();
if (!file_exists($this->filePath)) {
eZDebugSetting::writeDebug('kernel-clustering', "Writing stale file content to local file {$this->filePath}", __METHOD__);
eZFile::create(basename($this->filePath), dirname($this->filePath), $binaryData, true);
}
return $result;
}
// Check if we are allowed to store the data, if not just return the result
if (!$store) {
$this->abortCacheGeneration();
return $result;
}
// the .generating file is stored to DFS. $storeLocally is set to false
// since we don't want to store the .generating file locally, only
// the final file.
$this->storeContents($binaryData, $scope, $datatype, $storeLocally = false);
// we end the cache generation process, so that the .generating file
// is removed (we don't need to rename since contents was already stored
// above, using fileStoreContents
$this->endCacheGeneration();
if (self::LOCAL_CACHE) {
eZDebugSetting::writeDebug('kernel-clustering', "Creating local copy of the file", "dfs::storeCache( '{$this->filePath}' )");
eZFile::create(basename($this->filePath), dirname($this->filePath), $binaryData, true);
}
return $result;
}
$sitemap_index = '<?xml version="1.0" encoding="UTF-8"?>';
$sitemap_index .= '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
$limit = 40000;
$offset = 0;
$sql_count = "SELECT count(*) FROM do_sitemap ";
$sitemap_number = 1;
while ($offset < $count) {
$sitemap_file_name = 'sitemap_' . $sitemap_number . '.xml';
$sql = "SELECT dosm_loc , dosm_lastmod , dosm_priority , dosm_changefreq FROM do_sitemap LIMIT {$offset} , {$limit} ";
$results = $db->arrayQuery($sql);
$sm = '<?xml version="1.0" encoding="UTF-8"?>';
$sm .= '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
foreach ($results as $result) {
$sm .= '<url>';
$sm .= '<loc>' . $result['dosm_loc'] . '</loc>';
$sm .= '<lastmod>' . $result['dosm_lastmod'] . '</lastmod>';
$sm .= '<changefreq>' . $result['dosm_changefreq'] . '</changefreq>';
$sm .= '<priority>' . $result['dosm_priority'] . '</priority>';
$sm .= '</url>';
}
$sm .= '</urlset>';
eZFile::create($sitemap_file_name, eZSys::storageDirectory() . '/images/do_sitemap/', $sm);
$sitemap_index .= '<sitemap>';
$sitemap_index .= '<loc>' . $siteURL . '/' . eZSys::storageDirectory() . '/images/do_sitemap/' . $sitemap_file_name . '</loc>';
$sitemap_index .= '</sitemap>';
$offset = $offset + $limit;
$sitemap_number++;
}
$sitemap_index .= '</sitemapindex>';
eZFile::create('sitemap.xml', eZSys::storageDirectory() . '/images/do_sitemap/', $sitemap_index);
/**
*
* @param unknown_type $receiver
* @param unknown_type $subject
* @param unknown_type $message
* @param unknown_type $extraHeaders
* @param unknown_type $emailReturnPath
* @return file
*/
function createMailFile($receiver, $subject, $message, $extraHeaders, $emailReturnPath = '')
{
$sys = eZSys::instance();
$lineBreak = $sys->osType() == 'win32' ? "\r\n" : "\n";
// $separator = ($sys->osType() == 'win32' ? "\\" : "/" );
// $fileName = date("Ymd") .'-' .date("His").'-'.rand().'.mail';
$fileName = time() . '-' . rand() . '-cjw_nl.mail';
// $mailDir = eZSys::siteDir().eZSys::varDirectory().'/log/mail';
// $mailDir = eZSys::siteDir().'var/log/mail';
$data = $extraHeaders . $lineBreak;
if ($emailReturnPath != '') {
$data .= "Return-Path: <" . $emailReturnPath . ">" . $lineBreak;
}
$data .= "To: " . $receiver . $lineBreak;
$data .= "Subject: " . $subject . $lineBreak;
// $data .= "From: ".$emailSender.$lineBreak;
$data .= $lineBreak;
$data .= $message;
$data = preg_replace('/(\\r\\n|\\r|\\n)/', "\r\n", $data);
return eZFile::create($fileName, $this->mailDir, $data);
}
/**
* Creates the file $filePath with contents $fileContents on DB + DFS
*
* The existing file will be removed unless $params[remove] is set to false
*
* @param string $filePath relative file path
* @param string $fileContents file's content
* @param array $params
* Optional parameters for creation.
* Valid keys:datatype, scope, mtime, status, expired and remove
* if remove is set to true, the file will be removed before it is
* created
* @return void
**/
protected function createFile($filePath, $fileContents = 'foobar', $params = array())
{
$datatype = isset($params['datatype']) ? $params['datatype'] : 'text/test';
$scope = isset($params['scope']) ? $params['scope'] : 'test';
$mtime = isset($params['mtime']) ? $params['mtime'] : time();
$status = isset($params['status']) ? $params['status'] : 0;
$expired = isset($params['expired']) ? $params['expired'] : 0;
$createLocalFile = isset($params['create_local_file']) ? $params['create_local_file'] : false;
$remove = isset($params['remove']) ? $params['remove'] : true;
if ($remove) {
$this->removeFile($filePath);
}
$nameHash = md5($filePath);
$size = strlen($fileContents);
// create DB file
$sql = "INSERT INTO " . eZDFSFileHandlerMySQLBackend::TABLE_METADATA . " ( name, name_trunk, name_hash, datatype, scope, size, mtime, expired, status )" . "VALUES( '{$filePath}', '{$filePath}', '{$nameHash}', '{$datatype}', '{$scope}', '{$size}', '{$mtime}', '{$expired}', '{$status}' )";
$this->db->query($sql);
// create DFS file
$path = $this->makeDFSPath($filePath);
eZFile::create(basename($path), dirname($path), $fileContents);
// create local file
if ($createLocalFile) {
eZFile::create(basename($filePath), dirname($filePath), $fileContents);
}
}
function exportCollection($objectID = false, $dir = 'var/export', $format = 'csv', $separator = ',', $days = false, $debug = false)
{
$ret = false;
$object = false;
// Settings
$ini = eZINI::instance("cie.ini");
$excludeAttributeID = $ini->variable("CieSettings", "ExcludeAttributeID");
if (is_numeric($objectID)) {
$object =& eZContentObject::fetch($objectID);
$classID = $object->attribute('contentclass_id');
}
// eZDebug::writeDebug( $object );
if (is_numeric($classID)) {
$class =& eZContentClass::fetch($classID);
}
if ($debug == true) {
echo "Object ClassID: {$classID}\n";
}
if (is_object($class)) {
$className = $class->attribute('identifier');
$classDataMap = $class->attribute('data_map');
}
// Settings
$ini = eZINI::instance("cie.ini");
$excludeAttributeID = $ini->variable("CieSettings", "ExcludeAttributeID");
if ($debug == true) {
echo "Exporting Collection: {$objectID}\n";
echo "Output Directory: {$dir}\n";
echo "Output Format: {$format}\n";
echo "Output Separator: {$separator}\n";
echo "Object Collection ID: {$objectID}\n";
echo "Object Class Name: {$className}\n";
}
// if ( $debug == true )
// print_r( $classDataMap );
// print_r( $class );
// die( );
if (!$object) {
die('Encountered Non-Object, Unknown Error');
}
$collections = eZInformationCollection::fetchCollectionsList($objectID, false, false, array());
$collection_count = eZInformationCollection::fetchCollectionCountForObject($objectID);
if ($debug == true) {
echo "Object Collection Count: {$collection_count}\n\n";
echo "Object Collection Contents: \n";
print_r($collections);
}
$attributes_to_export = array();
// fetch collection class attributes for export
foreach ($classDataMap as $attribute) {
// print_r( $attribute );
if (is_object($attribute)) {
$is_ic = $attribute->attribute('is_information_collector');
if (is_numeric($is_ic)) {
if ($is_ic) {
$id = $attribute->attribute('id');
$name = $attribute->attribute('identifier');
$attributes_to_export[] = $id;
if ($debug) {
print_r("Object Class Attribute Name: {$name} \n");
// echo "Object Class Attribute is Information Collector: $is_ic\n";
print_r("Object Class Attribute ID: {$id} \n\n");
}
}
}
}
}
// Set output file name pattern
if ($days != false) {
$start = mktime(0, 0, 0, date("m"), date("d") - $days, date("Y"));
$namePattern = "_" . date("Y-m-d", $start) . "_to_" . date("Y-m-d");
} else {
$namePattern = "_export_" . date("Y-m-d_H-i");
}
// Set output file name
switch ($format) {
case 'csv':
$filename = $object->attribute('name') . $namePattern . ".csv";
break;
case 'sylk':
$filename = $object->attribute('name') . $namePattern . ".slk";
break;
default:
$filename = $object->attribute('name') . $namePattern . ".csv";
break;
}
$sdir = $dir . '/';
$path = $sdir . $filename;
if ($debug == true) {
echo "Collection Output Filename: {$filename}\n";
echo "Collection Output Path: {$path}\n";
}
if ($debug == true) {
echo "Class Attributes ot Export (Array): \n";
print_r($attributes_to_export);
echo "\n";
}
print_r("Object information collection record entries fetch in progress...\n");
$parser = new Parser();
$data = $parser->exportInformationCollection($collections, $attributes_to_export, $separator, $format, $days);
if ($debug == true) {
echo "Collection Output Content:\n";
echo "{$data}\n";
}
$file = new eZFile();
$file->create($filename, $dir, $data);
print_r("Object Collection Data Export File Path: {$path}\n");
print_r("Object Collection Export Completed!\n\n");
// flush();
// eZExecution::cleanExit();
}
function createFile($message)
{
$sys = eZSys::instance();
$lineBreak = $sys->osType() == 'win32' ? "\r\n" : "\n";
$separator = $sys->osType() == 'win32' ? "\\" : "/";
$fname = time() . '-' . rand() . '.sms';
$qdir = eZSys::siteDir() . eZSys::varDirectory() . $separator . 'mailq';
$data = $message;
$data = preg_replace('/(\\r\\n|\\r|\\n)/', "\r\n", $data);
// echo 'eZFile::create('.$fname.', '.$qdir.', '.$data.');';
eZFile::create($fname, $qdir, $data);
}
function storeImportResultToFile($importId, $data)
{
$fileName = getImportResultFilePath($importId);
$dir = dirname($fileName);
$file = basename($fileName);
// return content string of mail item
$messageData = serialize($data);
// create file in path with content
$createResult = eZFile::create($file, $dir, $messageData);
}
/**
* Creates the file $filePath on DFS with content $contents
*
* @param string $filePath
* @param binary $contents
*
* @return bool
*/
public function createFileOnDFS( $filePath, $contents )
{
$this->accumulatorStart();
$filePath = $this->makeDFSPath( $filePath );
$ret = eZFile::create( basename( $filePath ), dirname( $filePath ), $contents, false );
$this->accumulatorStop();
return $ret;
}
function clearMeta()
{
$content = array();
eZFile::create($this->MetaFileName, false, serialize($content), true);
}
/**
* Merges a collection of files togheter and returns array of paths to the files.
* js /css content is returned as string if packlevel is 0 and you use a js/ css generator.
* $fileArray can also be array of array of files, like array( 'file.js', 'file2.js', array( 'file5.js' ) )
* The name of the cached file is a md5 hash consistant of the file paths
* of the valid files in $file_array and the packlevel.
* The whole argument is used instead of file path on js/ css generators in the cache hash.
*
* @param array|string $fileArray Either array of file paths, or string with file path
* @param string $subPath In witch sub path of design folder to look for files.
* @param string $fileExtension File extension name (for use on cache file)
* @param int $packLevel Level of packing, values: 0-3
* @param bool $wwwInCacheHash To add www path in cahce hash or not
* @return array List of css files
*/
static function packFiles($fileArray, $subPath = '', $fileExtension = '.js', $packLevel = 2, $wwwInCacheHash = false)
{
if (!$fileArray) {
return array();
} else {
if (!is_array($fileArray)) {
$fileArray = array($fileArray);
}
}
$cacheName = '';
$lastmodified = 0;
$httpFiles = array();
$validFiles = array();
$validWWWFiles = array();
$bases = eZTemplateDesignResource::allDesignBases();
// Only pack files if Packer is enabled and if not set DevelopmentMode is disabled
$ezjscINI = eZINI::instance('ezjscore.ini');
if ($ezjscINI->hasVariable('eZJSCore', 'Packer')) {
$packerIniValue = $ezjscINI->variable('eZJSCore', 'Packer');
if ($packerIniValue === 'disabled') {
$packLevel = 0;
} else {
if (is_numeric($packerIniValue)) {
$packLevel = (int) $packerIniValue;
}
}
} else {
$ini = eZINI::instance();
if ($ini->variable('TemplateSettings', 'DevelopmentMode') === 'enabled') {
$packLevel = 0;
}
}
$packerInfo = array('file_extension' => $fileExtension, 'pack_level' => $packLevel, 'sub_path' => $subPath, 'cache_dir' => self::getCacheDir(), 'www_dir' => self::getWwwDir());
// needed for image includes to work on ezp installs with mixed access methods (virtualhost + url based setup)
if ($wwwInCacheHash) {
$cacheName = $packerInfo['www_dir'];
}
while (count($fileArray) > 0) {
$file = array_shift($fileArray);
// if $file is array, concat it to the file array and continue
if ($file && is_array($file)) {
$fileArray = array_merge($file, $fileArray);
continue;
} else {
if (!$file) {
continue;
} else {
if (strpos($file, '::') !== false) {
$server = self::serverCallHelper(explode('::', $file));
$fileTime = $server->getCacheTime($packerInfo);
// generate content straight away if packing is disabled
if ($packLevel === 0) {
$validWWWFiles[] = $server->call($fileArray);
} else {
if ($fileTime === -1) {
$validFiles[] = $server->call($fileArray);
} else {
$validFiles[] = $server;
$cacheName .= $file . '_';
}
}
$lastmodified = max($lastmodified, $fileTime);
continue;
} else {
if (strpos($file, 'http://') === 0 || strpos($file, 'https://') === 0) {
$httpFiles[] = $file;
continue;
} else {
if (strpos($file, 'var/') === 0) {
if (substr($file, 0, 2) === '//' || preg_match("#^[a-zA-Z0-9]+:#", $file)) {
$file = '/';
} else {
if (strlen($file) > 0 && $file[0] !== '/') {
$file = '/' . $file;
}
}
eZURI::transformURI($file, true, 'relative');
// get file time and continue if it return false
$file = str_replace('//' . $packerInfo['www_dir'], '', '//' . $file);
$fileTime = file_exists($file) ? filemtime($file) : false;
$wwwFile = $packerInfo['www_dir'] . $file;
} else {
// allow path to be outside subpath if it starts with '/'
if ($file[0] === '/') {
$file = ltrim($file, '/');
} else {
$file = $subPath . $file;
}
$triedFiles = array();
$match = eZTemplateDesignResource::fileMatch($bases, '', $file, $triedFiles);
if ($match === false) {
eZDebug::writeWarning("Could not find: {$file}", __METHOD__);
continue;
}
$file = htmlspecialchars($match['path']);
$fileTime = file_exists($file) ? filemtime($file) : false;
$wwwFile = $packerInfo['www_dir'] . $file;
}
}
}
}
}
if ($fileTime === false) {
eZDebug::writeWarning("Could not get modified time of file: {$file}", __METHOD__);
continue;
}
// calculate last modified time and store in arrays
$lastmodified = max($lastmodified, $fileTime);
$validFiles[] = $file;
$validWWWFiles[] = $wwwFile;
// STEVO
$cacheName .= $file . '_' . $fileTime . '_';
}
// if packing is disabled, return the valid paths / content we have generated
if ($packLevel === 0) {
return array_merge($httpFiles, $validWWWFiles);
}
if (!$validFiles) {
eZDebug::writeWarning("Could not find any files: " . var_export($fileArray, true), __METHOD__);
return array();
}
// generate cache file name and path
$cacheName = md5($cacheName . $packLevel) . $fileExtension;
$cachePath = $packerInfo['cache_dir'] . $subPath;
if (file_exists($cachePath . $cacheName)) {
// check last modified time and return path to cache file if valid
if ($lastmodified <= filemtime($cachePath . $cacheName)) {
$httpFiles[] = $packerInfo['www_dir'] . $cachePath . $cacheName;
return $httpFiles;
}
}
// Merge file content and create new cache file
$content = '';
foreach ($validFiles as $file) {
// if this is a js / css generator, call to get content
if ($file instanceof ezjscServerRouter) {
$content .= $file->call($validFiles);
continue;
} else {
if (!$file) {
continue;
}
}
// else, get content of normal file
$fileContent = file_get_contents($file);
if (!trim($fileContent)) {
$content .= "/* empty: {$file} */\r\n";
continue;
}
// we need to fix relative background image paths if this is a css file
if (strpos($fileExtension, '.css') !== false) {
$fileContent = ezjscPacker::fixImgPaths($fileContent, $file);
}
$content .= "/* start: {$file} */\r\n";
$content .= $fileContent;
$content .= "\r\n/* end: {$file} */\r\n\r\n";
}
// Pack the file to save bandwidth
if ($packLevel > 1) {
if (strpos($fileExtension, '.css') !== false) {
$content = ezjscPacker::optimizeCSS($content, $packLevel);
} else {
$content = ezjscPacker::optimizeScript($content, $packLevel);
}
}
// save file and return path if sucsessfull
if (eZFile::create($cacheName, $cachePath, $content)) {
$httpFiles[] = $packerInfo['www_dir'] . $cachePath . $cacheName;
return $httpFiles;
}
return array();
}
protected function createFile($filePath, $contents, $atomic = true)
{
$createResult = eZFile::create(basename($filePath), dirname($filePath), $contents, $atomic);
if ($createResult) {
$this->fixPermissions($filePath);
}
return $createResult;
}
/**
* Creates the file $filePath with contents $fileContents on DB + DFS
*
* The existing file will be removed unless $params[remove] is set to false
*
* @param string $filePath relative file path
* @param string $fileContents file's content
* @param array $params
* Optional parameters for creation.
* Valid keys:datatype, scope, mtime, expired and remove
* if remove is set to true, the file will be removed before it is
* created
* @return void
**/
protected function createFile($filePath, $fileContents = 'foobar', $params = array())
{
$datatype = isset($params['datatype']) ? $params['datatype'] : 'text/test';
$scope = isset($params['scope']) ? $params['scope'] : 'test';
$mtime = isset($params['mtime']) ? $params['mtime'] : time();
$expired = isset($params['expired']) ? $params['expired'] : 0;
$createLocalFile = isset($params['create_local_file']) ? $params['create_local_file'] : false;
$remove = isset($params['remove']) ? $params['remove'] : true;
if ($remove) {
$this->removeFile($filePath);
}
$nameHash = md5($filePath);
$size = strlen($fileContents);
// create DB file
$sql = "INSERT INTO " . self::$tableDefault . " ( name, name_trunk, name_hash, datatype, scope, size, mtime, expired )" . "VALUES( '{$filePath}', '{$filePath}', '{$nameHash}', '{$datatype}', '{$scope}', '{$size}', '{$mtime}', '{$expired}' )";
$this->db->query($sql);
// create DFS file
$path = $this->makeDFSPath($filePath);
eZFile::create(basename($path), dirname($path), $fileContents);
// create local file
if ($createLocalFile) {
eZFile::create(basename($filePath), dirname($filePath), $fileContents);
}
return eZClusterFileHandler::instance($filePath);
}
/**
* Stores the data in $fileData to the remote and local file and commits the
* transaction.
*
* The parameter $fileData must contain the same as information as the
* $generateCallback returns as explained in processCache().
* @note This method is just a continuation of the code in processCache()
* and is not meant to be called alone since it relies on specific
* state in the database.
*/
public function storeCache($fileData)
{
$scope = false;
$datatype = false;
$binaryData = null;
$fileContent = null;
$store = true;
$storeCache = false;
if (is_array($fileData)) {
if (isset($fileData['scope'])) {
$scope = $fileData['scope'];
}
if (isset($fileData['datatype'])) {
$datatype = $fileData['datatype'];
}
if (isset($fileData['content'])) {
$fileContent = $fileData['content'];
}
if (isset($fileData['binarydata'])) {
$binaryData = $fileData['binarydata'];
}
if (isset($fileData['store'])) {
$store = $fileData['store'];
}
} else {
$binaryData = $fileData;
}
// This checks if we entered timeout and got our generating file stolen
// If this happens, we don't store our cache
if ($store and $this->checkCacheGenerationTimeout()) {
$storeCache = true;
}
$result = null;
if ($binaryData === null && $fileContent === null) {
eZDebug::writeError("Write callback need to set the 'content' or 'binarydata' entry for '{$this->filePath}'", __METHOD__);
$this->abortCacheGeneration();
return null;
}
if ($binaryData === null) {
$binaryData = "<" . "?php\n\treturn " . var_export($fileContent, true) . ";\n?" . ">\n";
}
if ($fileContent === null) {
$result = $binaryData;
} else {
$result = $fileContent;
}
if (!$this->filePath) {
return $result;
}
// no store advice from cache generation timeout or disabled viewcache,
// we just return the result
if (!$storeCache) {
eZDebugSetting::writeDebug('kernel-clustering', "Not storing this cache", __METHOD__);
$this->abortCacheGeneration();
return $result;
}
// stale cache handling: we just return the result, no lock has been set
if ($this->useStaleCache) {
eZDebugSetting::writeDebug('kernel-clustering', "Stalecache mode enabled for this cache", "dfs::storeCache( {$this->filePath} )");
// we write the generated cache to disk if it does not exist yet,
// to speed up the next uncached operation
// This file will be overwritten by the real file
clearstatcache();
if (!file_exists($this->filePath)) {
eZDebugSetting::writeDebug('kernel-clustering', "Writing stale file content to local file {$this->filePath}", __METHOD__);
eZFile::create(basename($this->filePath), dirname($this->filePath), $binaryData, true);
}
return $result;
}
// Check if we are allowed to store the data, if not just return the result
if (!$store) {
$this->abortCacheGeneration();
return $result;
}
// Distinguish bool from eZClusterFileFailure, and call abortCacheGeneration()
$storeContentsResult = $this->storeContents($binaryData, $scope, $datatype, $storeLocally = false);
// Cache was stored, we end cache generation
if ($storeContentsResult === true) {
$this->endCacheGeneration();
} else {
if ($storeContentsResult instanceof eZMySQLBackendError) {
$this->abortCacheGeneration();
}
}
// We don't do anything if false (not stored for known reasons) has been returned
return $result;
}
protected function createFile($path, $content)
{
return eZFile::create(basename($path), dirname($path), $content, false);
}
function clearMeta()
{
$tmpFile = $this->MetaFileName . substr(md5(mt_rand()), 0, 8);
$content = array();
eZFile::create($tmpFile, false, serialize($content));
eZFile::rename($tmpFile, $this->MetaFileName);
}
public function generatePng($url, $density, $keys)
{
$data = $this->getPDF($url);
// check if error occurred during pdf generation
if ($data === false) {
return false;
}
// save pdf, generate png, return url
$cacheName = hash("md5", $url . '-' . $density . '-' . implode($keys, '-'));
$cacheDir = self::getCacheDir();
eZFile::create($cacheName . '.pdf', $cacheDir, $data);
$pdfUrl = $cacheDir . $cacheName . '.pdf';
$pngUrl = $cacheDir . $cacheName . '.png';
$command = "gs -dNOPAUSE -dBATCH -sDEVICE=pngalpha -r{$density} -dEPSCrop -sOutputFile=" . eZSys::rootDir() . "/" . $pngUrl . " " . eZSys::rootDir() . "/" . $pdfUrl;
exec($command, $output, $returnCode);
//eZDebug::writeError($command, 'sPdf2png::exportPng');
//eZDebug::writeError("pngUrl=".$pngUrl, 'sPdf2png::exportPng');
//eZFileHandler::unlink($pdfUrl);
return $this->getPngData($pngUrl);
/*return array('url' => ,
'width' => '100',
'height' => '100' );*/
}
protected function createFile($filePath, $contents, $atomic = true)
{
// $contents can result from a failed file_get_contents(). In this case
if ($contents === false) {
return false;
}
$createResult = eZFile::create(basename($filePath), dirname($filePath), $contents, $atomic);
if ($createResult) {
$this->fixPermissions($filePath);
}
return $createResult;
}
$processor = new ExportProcessor($exporter, $formatter);
$processor->export();
// Rendering or splitting ?
$exportDir = eZSys::varDirectory();
$exportBaseFilename = 'comments-export';
$exportFormat = $processor->getExportFormat();
if (isset($options['split'])) {
$cli->notice('Now splitting final file.');
$splittedData = $processor->split();
$cli->notice('Total size before splitting is ' . number_format($splittedData->totalSize / 1024 / 1024, 2) . 'M');
foreach ($splittedData->stringArray as $i => $data) {
$filename = "{$exportBaseFilename}.{$i}.{$exportFormat}";
$cli->notice("Now rendering {$exportDir}/{$filename}");
eZFile::create("{$filename}", $exportDir, $data, true);
}
} else {
$cli->notice("Now rendering to {$exportDir}/{$exportBaseFilename}.{$exportFormat}");
eZFile::create("{$exportBaseFilename}.{$exportFormat}", $exportDir, $processor->render(), true);
}
$memoryMax = memory_get_peak_usage();
$memoryMax = round($memoryMax / 1024 / 1024, 2);
// Convert in Megabytes
$cli->notice('Peak memory usage : ' . $memoryMax . 'M');
$script->shutdown();
} catch (Exception $e) {
$errCode = $e->getCode();
$errCode = $errCode != 0 ? $errCode : 1;
// If an error has occured, script must terminate with a status other than 0
$cli->error($e->getMessage());
$script->shutdown($errCode);
}
/**
* Store file contents to disk
*
* @param string $contents Binary file data
* @param string $datatype Not used in the FS handler
* @param string $scope Not used in the FS handler
* @param bool $storeLocally Not used in the FS handler
*
* @return void
*/
function storeContents($contents, $scope = false, $datatype = false, $storeLocally = false)
{
$filePath = $this->filePath;
eZDebugSetting::writeDebug('kernel-clustering', "fs::storeContents( '{$filePath}' )", __METHOD__);
eZDebug::accumulatorStart('dbfile', false, 'dbfile');
eZFile::create(basename($filePath), dirname($filePath), $contents, true);
$perm = eZINI::instance()->variable('FileSettings', 'StorageFilePermissions');
chmod($filePath, octdec($perm));
eZDebug::accumulatorStop('dbfile');
}
function storeCache($fileData)
{
$scope = false;
$datatype = false;
$binaryData = null;
$fileContent = null;
$store = true;
$storeCache = false;
if (is_array($fileData)) {
if (isset($fileData['scope'])) {
$scope = $fileData['scope'];
}
if (isset($fileData['datatype'])) {
$datatype = $fileData['datatype'];
}
if (isset($fileData['content'])) {
$fileContent = $fileData['content'];
}
if (isset($fileData['binarydata'])) {
$binaryData = $fileData['binarydata'];
}
if (isset($fileData['store'])) {
$store = $fileData['store'];
}
} else {
$binaryData = $fileData;
}
// This checks if we entered timeout and got our generating file stolen
// If this happens, we don't store our cache
if ($store and $this->checkCacheGenerationTimeout()) {
$storeCache = true;
}
$mtime = false;
$result = null;
if ($binaryData === null && $fileContent === null) {
eZDebug::writeError("Write callback need to set the 'content' or 'binarydata' entry");
$this->abortCacheGeneration();
return null;
}
if ($binaryData === null) {
$binaryData = "<" . "?php\n\treturn " . var_export($fileContent, true) . ";\n?" . ">\n";
}
if ($fileContent === null) {
$result = $binaryData;
} else {
$result = $fileContent;
}
if (!$this->filePath) {
return $result;
}
// no store advice, we just return the result
if (!$storeCache) {
$this->abortCacheGeneration();
return $result;
}
// stale cache handling: we just return the result, no lock has been set
if ($this->useStaleCache) {
// we write the generated cache to disk if it does not exist yet,
// to speed up the next uncached operation
// This file will be overwritten by the real file
clearstatcache();
if (!file_exists($this->filePath)) {
eZDebugSetting::writeDebug('kernel-clustering', "Writing stale file content to local file {$this->filePath}");
eZFile::create(basename($this->filePath), dirname($this->filePath), $binaryData, true);
}
return $result;
}
// Check if we are allowed to store the data, if not just return the result
if (!$store) {
$this->abortCacheGeneration();
return $result;
}
eZDebugSetting::writeDebug('kernel-clustering', "Writing new file content to database for {$this->filePath}");
$this->storeContents($binaryData, $scope, $datatype, $storeLocally = false);
// we end the cache generation process, so that the .generating file
// is renamed to its final name
$this->endCacheGeneration(strlen($binaryData), $scope, $datatype);
// the generated file is written to disk
if (self::LOCAL_CACHE) {
// Store content also locally
eZDebugSetting::writeDebug('kernel-clustering', "Writing new file content to local file {$this->filePath}");
eZFile::create(basename($this->filePath), dirname($this->filePath), $binaryData, true);
}
return $result;
}
