function copyImagesToDB($remove)
{
global $cli, $fileHandler;
$db = eZDB::instance();
$cli->output("Importing images and imagealiases files to database:");
$rows = $db->arrayQuery('select filepath from ezimagefile');
foreach ($rows as $row) {
$filePath = $row['filepath'];
$cli->output("- " . $filePath);
$mimeData = eZMimeType::findByFileContents($filePath);
$fileHandler->fileStore($filePath, 'image', $remove, $mimeData['name']);
}
}
/**
* Image information for $aliasName. This is the information which normally
* would be provided during generation of aliasName. This so that requests
* not holding the lock will provide meaningful information.
*
* @param mixed $mimeData
* @param string $aliasName
* @return array
*/
function imageAliasInfo( $mimeData, $aliasName, $isAliasNew = false )
{
if ( is_string( $mimeData ) )
$mimeData = eZMimeType::findByFileContents( $mimeData );
$this->analyzeImage( $mimeData );
if ( $aliasName )
{
$aliasList = $this->aliasList();
if ( isset( $aliasList[$aliasName] ) )
{
$alias = $aliasList[$aliasName];
if ( $alias['mime_type'] )
{
eZMimeType::changeMIMEType( $mimeData, $alias['mime_type'] );
}
}
}
if ( $aliasName != 'original' )
{
$mimeData['filename'] = $mimeData['basename'] . '_' . $aliasName . '.' . $mimeData['suffix'];
$mimeData['url'] = $mimeData['dirpath'] . '/' . $mimeData['filename'];
}
// eZDebug::writeDebug( $mimeData, __METHOD__ );
return $mimeData;
}
function validateImageFiles( $package, $http, $currentStepID, &$stepMap, &$persistentData, &$errorList )
{
// If we don't have an image we continue as normal
if ( !eZHTTPFile::canFetch( 'PackageImageFile' ) )
return true;
$file = eZHTTPFile::fetch( 'PackageImageFile' );
$result = true;
if ( $file )
{
$mimeData = eZMimeType::findByFileContents( $file->attribute( 'original_filename' ) );
$dir = eZSys::storageDirectory() . '/temp';
eZMimeType::changeDirectoryPath( $mimeData, $dir );
$file->store( false, false, $mimeData );
$persistentData['imagefiles'][] = $mimeData;
$result = false;
}
return $result;
}
function fetchVirtualSiteContent( $site, $depth, $properties )
{
$this->appendLogEntry( "Script URL.." . eZSys::instance()->RequestURI, 'CS:fetchVirtualSiteContent' );
// Location of the info file.
$infoFile = $_SERVER['DOCUMENT_ROOT'] . '/' . eZWebDAVContentServer::virtualInfoFileName();
// Always add the current collection
$contentEntry = array();
$contentEntry["name"] = eZSys::instance()->RequestURI;
$contentEntry["size"] = 0;
$contentEntry["mimetype"] = 'httpd/unix-directory';
$contentEntry["ctime"] = filectime( 'settings/siteaccess/' . $site );
$contentEntry["mtime"] = filemtime( 'settings/siteaccess/' . $site );
$contentEntry["href"] = eZSys::instance()->RequestURI;
$entries[] = $contentEntry;
$defctime = $contentEntry['ctime'];
$defmtime = $contentEntry['mtime'];
if ( $depth > 0 )
{
$scriptURL = eZSys::instance()->RequestURI;
if ( $scriptURL{strlen($scriptURL) - 1} != "/" )
$scriptURL .= "/";
// Set up attributes for the virtual content folder:
foreach ( $this->virtualInfoList() as $info )
{
$name = $info['name'];
$filepath = false;
if ( isset( $info['filepath'] ) )
$filepath = $info['filepath'];
$size = 0;
if ( $filepath === false or file_exists( $filepath ) )
{
$mimeType = 'httpd/unix-directory';
if ( $filepath !== false )
{
$mimeInfo = eZMimeType::findByFileContents( $filepath );
$mimeType = $mimeInfo['name'];
$ctime = filectime( $filepath );
$mtime = filemtime( $filepath );
$size = filesize( $filepath );
}
else
{
$ctime = $defctime;
$mtime = $defmtime;
}
$entry = array();
$entry["name"] = $name;
$entry["size"] = $size;
$entry["mimetype"] = $mimeType;
$entry["ctime"] = $ctime;
$entry["mtime"] = $mtime;
$entry["href"] = $scriptURL . $name;
$entries[] = $entry;
}
}
}
return $entries;
}
/**
* Function for insert image
*/
function callImage($info)
{
$params = array();
$leftMargin = false;
$rightMargin = false;
eZPDFTable::extractParameters($info['p'], 0, $params, true);
$filename = rawurldecode($params['src']);
$mimetype = eZMimeType::findByFileContents($filename);
$this->transaction('start');
if (!isset($params['static'])) {
$params['static'] = false;
}
if ($this->yOffset() - $params['height'] < $this->ez['bottomMargin']) {
$this->ezNewPage();
}
if (isset($params['dpi'])) {
$newWidth = (int) ($params['width'] * ((int) $params['dpi'] / 72));
$newHeight = (int) ($params['height'] * ((int) $params['dpi'] / 72));
$newFilename = eZSys::cacheDirectory() . '/' . md5(mt_rand()) . '.jpg';
while (file_exists($newFilename)) {
$newFilename = eZSys::cacheDirectory() . '/' . md5(mt_rand()) . '.jpg';
}
$img = eZImageManager::factory();
$newImg = $img->convert($filename, $newFilename, false, array('filters' => array(array('name' => 'geometry/scaledownonly', 'data' => array($newWidth, $newHeight)))));
$filename = $newFilename['url'];
}
$drawableAreaWidth = $this->ez['pageWidth'] - $this->ez['leftMargin'] - $this->ez['rightMargin'];
switch ($params['align']) {
case 'right':
$xOffset = $this->ez['pageWidth'] - ($this->rightMargin() + $params['width']);
$rightMargin = $this->rightMargin() + $params['width'];
if ($rightMargin > $drawableAreaWidth + $this->rightMargin()) {
// the image is equal or larger then width of the page(of the drawable area) => no point
// to set $rightMargin and next object(text, image, ...) should be outputted below the image.
$rightMargin = false;
}
break;
case 'center':
$xOffset = ($this->ez['pageWidth'] - $this->rightMargin() - $this->leftMargin()) / 2 + $this->leftMargin() - $params['width'] / 2;
break;
case 'left':
default:
$xOffset = $this->leftMargin();
$leftMargin = $this->leftMargin() + $params['width'];
if ($leftMargin > $drawableAreaWidth + $this->leftMargin()) {
// the image is equal or larger then width of the page(of the drawable area) => no point
// to set $leftMargin and next object(text, image, ...) should be outputted below the image.
$leftMargin = false;
}
break;
}
if (isset($params['x'])) {
$xOffset = $params['x'];
$leftMargin = false;
$rightMargin = false;
}
$yOffset = $this->yOffset();
$whileCount = 0;
if ($params['width'] < $drawableAreaWidth) {
while ($this->leftMargin($yOffset) > $xOffset && ++$whileCount < 100) {
$yOffset -= 10;
}
}
$yOffset -= $params['height'];
$yOffset += $this->lineHeight() / 2;
if (isset($params['y'])) {
$yOffset = $params['y'];
}
if ($leftMargin !== false) {
$this->setLimitedLeftMargin($yOffset - 7, $yOffset + $params['height'] + 7, $leftMargin + 7);
}
if ($rightMargin !== false) {
$this->setLimitedRightMargin($yOffset - 7, $yOffset + $params['height'] + 7, $rightMargin + 7);
}
switch ($mimetype['name']) {
case 'image/gif':
$newFilename = eZSys::cacheDirectory() . '/' . md5(mt_rand()) . '.jpg';
while (file_exists($newFilename)) {
$newFilename = eZSys::cacheDirectory() . '/' . md5(mt_rand()) . '.jpg';
}
$newMimetype = eZMimeType::findByURL($newFilename);
$img = eZImageManager::factory();
$newImg = $img->convert($mimetype, $newMimetype, false, array());
$this->addJpegFromFile($newMimetype['url'], $xOffset, $yOffset, $params['width'], $params['height']);
break;
case 'image/jpeg':
$this->addJpegFromFile($filename, $xOffset, $yOffset, $params['width'], $params['height']);
break;
case 'image/png':
if ($this->addPngFromFile($filename, $xOffset, $yOffset, $params['width'], $params['height']) === false) {
$this->transaction('abort');
return;
}
break;
default:
eZDebug::writeError('Unsupported image file type, ' . $mimetype['name'], __METHOD__);
$this->transaction('abort');
return;
break;
}
$this->transaction('commit');
if (!$leftMargin && !$rightMargin && !$params['static']) {
$this->y -= $params['height'] + $this->lineHeight();
}
return array('y' => $params['height'] + $this->lineHeight());
}
/**
* Fetches the HTTP-File into $file and fills in MIME-Type information into $mimeData.
*
* @return bool false if something went wrong.
*/
function fetchHTTPFile($httpFileIdentifier, &$errors, &$file, &$mimeData)
{
$returnCode = eZHTTPFile::canFetch($httpFileIdentifier, 0);
if ($returnCode !== eZHTTPFile::UPLOADEDFILE_OK && $returnCode !== true) {
switch ($returnCode) {
case eZHTTPFile::UPLOADEDFILE_DOES_NOT_EXIST:
$errors[] = array('description' => ezpI18n::tr('kernel/content/upload', 'A file is required for upload, no file were found.'));
break;
case eZHTTPFile::UPLOADEDFILE_EXCEEDS_PHP_LIMIT:
case eZHTTPFile::UPLOADEDFILE_EXCEEDS_MAX_SIZE:
$errors[] = array('description' => ezpI18n::tr('kernel/content/upload', 'The uploaded file size is above the maximum limit.'));
break;
case eZHTTPFile::UPLOADEDFILE_MISSING_TMP_DIR:
case eZHTTPFile::UPLOADEDFILE_CANT_WRITE:
case eZHTTPFile::UPLOADEDFILE_UNKNOWN_ERROR:
$errors[] = array('description' => ezpI18n::tr('kernel/content/upload', 'A system error occured while writing the uploaded file.'));
break;
}
return false;
}
$file = eZHTTPFile::fetch($httpFileIdentifier);
if (!$file instanceof eZHTTPFile) {
$errors[] = array('description' => ezpI18n::tr('kernel/content/upload', 'Expected a eZHTTPFile object but got nothing.'));
return false;
}
$mimeData = eZMimeType::findByFileContents($file->attribute("original_filename"));
return true;
}
function storedFilename(&$binary, $returnMimeData = false)
{
$origDir = eZSys::storageDirectory() . '/original';
$class = get_class($binary);
$fileName = false;
$originalFilename = false;
if (in_array($class, array('eZBinaryFile', 'eZMedia'))) {
$fileName = $origDir . "/" . $binary->attribute('mime_type_category') . '/' . $binary->attribute("filename");
$originalFilename = $binary->attribute('original_filename');
} else {
if ($class == 'eZImageAliasHandler') {
$alias = $binary->attribute('original');
if ($alias) {
$fileName = $alias['url'];
}
$originalFilename = $binary->attribute('original_filename');
}
}
if ($fileName) {
$mimeData = eZMimeType::findByFileContents($fileName);
$mimeData['original_filename'] = $originalFilename;
if (!isset($mimeData['name'])) {
$mimeData['name'] = 'application/octet-stream';
}
if ($returnMimeData) {
return $mimeData;
} else {
return $mimeData['url'];
}
}
return false;
}
function generateXMLData()
{
$doc = new DOMDocument('1.0', 'utf-8');
$imageNode = $doc->createElement("ezimage");
$doc->appendChild($imageNode);
$fileName = false;
$imageManager = eZImageManager::factory();
$mimeData = eZMimeType::findByFileContents($fileName);
$imageManager->analyzeImage($mimeData);
$imageNode->setAttribute('serial_number', false);
$imageNode->setAttribute('is_valid', false);
$imageNode->setAttribute('filename', $fileName);
$imageNode->setAttribute('suffix', false);
$imageNode->setAttribute('basename', false);
$imageNode->setAttribute('dirpath', false);
$imageNode->setAttribute('url', false);
$imageNode->setAttribute('original_filename', false);
$imageNode->setAttribute('mime_type', false);
$imageNode->setAttribute('width', false);
$imageNode->setAttribute('height', false);
$imageNode->setAttribute('alternative_text', false);
$imageNode->setAttribute('alias_key', $imageManager->createImageAliasKey($imageManager->alias('original')));
$imageNode->setAttribute('timestamp', time());
$this->createImageInformationNode($imageNode, $mimeData);
$this->storeDOMTree($doc, true, false);
}
function insertRegularFile( $object, $objectVersion, $objectLanguage,
$objectAttribute, $filePath,
&$result )
{
$result = array( 'errors' => array(),
'require_storage' => false );
$attributeID = $objectAttribute->attribute( 'id' );
$binary = eZBinaryFile::fetch( $attributeID, $objectVersion );
if ( $binary === null )
$binary = eZBinaryFile::create( $attributeID, $objectVersion );
$fileName = basename( $filePath );
$mimeData = eZMimeType::findByFileContents( $filePath );
$storageDir = eZSys::storageDirectory();
list( $group, $type ) = explode( '/', $mimeData['name'] );
$destination = $storageDir . '/original/' . $group;
if ( !file_exists( $destination ) )
{
if ( !eZDir::mkdir( $destination, false, true ) )
{
return false;
}
}
// create dest filename in the same manner as eZHTTPFile::store()
// grab file's suffix
$fileSuffix = eZFile::suffix( $fileName );
// prepend dot
if( $fileSuffix )
$fileSuffix = '.' . $fileSuffix;
// grab filename without suffix
$fileBaseName = basename( $fileName, $fileSuffix );
// create dest filename
$destFileName = md5( $fileBaseName . microtime() . mt_rand() ) . $fileSuffix;
$destination = $destination . '/' . $destFileName;
copy( $filePath, $destination );
$fileHandler = eZClusterFileHandler::instance();
$fileHandler->fileStore( $destination, 'binaryfile', true, $mimeData['name'] );
$binary->setAttribute( "contentobject_attribute_id", $attributeID );
$binary->setAttribute( "version", $objectVersion );
$binary->setAttribute( "filename", $destFileName );
$binary->setAttribute( "original_filename", $fileName );
$binary->setAttribute( "mime_type", $mimeData['name'] );
$binary->store();
$objectAttribute->setContent( $binary );
return true;
}
$newBaseName = $objectName;
}
if ($newFilePath != $filePath) {
if (!file_exists($newDirPath)) {
eZDir::mkdir($newDirPath, false, true);
}
eZFileHandler::copy($filePath, $newFilePath);
$filePath = $newFilePath;
$fileName = $newFileName;
$suffix = $newSuffix;
$dirPath = $newDirPath;
$baseName = $newBaseName;
}
}
}
$mimeData = eZMimeType::findByFileContents($fileName);
$imageManager->analyzeImage($mimeData);
$imageNode->setAttribute('serial_number', false);
$imageNode->setAttribute('is_valid', $isValid);
$imageNode->setAttribute('filename', $fileName);
$imageNode->setAttribute('suffix', $suffix);
$imageNode->setAttribute('basename', $baseName);
$imageNode->setAttribute('dirpath', $dirPath);
$imageNode->setAttribute('url', $filePath);
$imageNode->setAttribute('original_filename', $originalFileName);
$imageNode->setAttribute('mime_type', $mimeType);
$imageNode->setAttribute('width', $width);
$imageNode->setAttribute('height', $height);
$imageNode->setAttribute('alternative_text', $altText);
$imageNode->setAttribute('alias_key', $imageManager->createImageAliasKey($imageManager->alias('original')));
$imageNode->setAttribute('timestamp', time());
function insertRegularFile($object, $objectVersion, $objectLanguage, $objectAttribute, $filePath, &$result)
{
$result = array('errors' => array(), 'require_storage' => false);
$attributeID = $objectAttribute->attribute('id');
$media = eZMedia::fetch($attributeID, $objectVersion);
if ($media === null) {
$media = eZMedia::create($attributeID, $objectVersion);
}
$fileName = basename($filePath);
$mimeData = eZMimeType::findByFileContents($filePath);
$storageDir = eZSys::storageDirectory();
list($group, $type) = explode('/', $mimeData['name']);
$destination = $storageDir . '/original/' . $group;
if (!file_exists($destination)) {
if (!eZDir::mkdir($destination, false, true)) {
return false;
}
}
// create dest filename in the same manner as eZHTTPFile::store()
// grab file's suffix
$fileSuffix = eZFile::suffix($fileName);
// prepend dot
if ($fileSuffix) {
$fileSuffix = '.' . $fileSuffix;
}
// grab filename without suffix
$fileBaseName = basename($fileName, $fileSuffix);
// create dest filename
$destFileName = md5($fileBaseName . microtime() . mt_rand()) . $fileSuffix;
$destination = $destination . '/' . $destFileName;
copy($filePath, $destination);
$fileHandler = eZClusterFileHandler::instance();
$fileHandler->fileStore($destination, 'mediafile', true, $mimeData['name']);
$classAttribute = $objectAttribute->contentClassAttribute();
$player = $classAttribute->attribute("data_text1");
$pluginPage = eZMediaType::pluginPage($player);
$media->setAttribute("contentobject_attribute_id", $attributeID);
$media->setAttribute("version", $objectVersion);
$media->setAttribute("filename", $destFileName);
$media->setAttribute("original_filename", $fileName);
$media->setAttribute("mime_type", $mimeData['name']);
// Setting width and height to zero means that the browser/player must find the size itself.
// In the future we will probably analyze the media file and find this information
$width = $height = 0;
// Quality is not known, so we don't set any
$quality = false;
// Not sure what this is for, set to false
$controls = false;
// We want to show controllers by default
$hasController = true;
// Don't play automatically
$isAutoplay = false;
// Don't loop movie
$isLoop = false;
$media->setAttribute("width", $width);
$media->setAttribute("height", $height);
$media->setAttribute("quality", $quality);
$media->setAttribute("controls", $controls);
$media->setAttribute("pluginspage", $pluginPage);
$media->setAttribute("is_autoplay", $isAutoplay);
$media->setAttribute("has_controller", $hasController);
$media->setAttribute("is_loop", $isLoop);
$media->store();
$objectAttribute->setContent($media);
return true;
}
/**
* Outputs file contents prepending them with appropriate HTTP headers.
*
* \public
*/
function passthrough()
{
$path = $this->filePath;
eZDebugSetting::writeDebug('kernel-clustering', "fs::passthrough()", __METHOD__);
eZDebug::accumulatorStart('dbfile', false, 'dbfile');
$mimeData = eZMimeType::findByFileContents($path);
// $mimeType = $mimeData['name'];
$mimeType = 'application/octec-stream';
$contentLength = filesize($path);
header("Content-Length: {$contentLength}");
header("Content-Type: {$mimeType}");
header("Expires: " . gmdate('D, d M Y H:i:s', time() + 6000) . 'GMT');
header("Connection: close");
readfile($path);
eZDebug::accumulatorStop('dbfile');
}
function fetchHTTPFile($httpFileIdentifier, &$errors, &$file, &$mimeData)
{
if (!eZHTTPFile::canFetch($httpFileIdentifier)) {
$errors[] = array('description' => ezpI18n::tr('kernel/content/upload', 'A file is required for upload, no file were found.'));
return false;
}
$file = eZHTTPFile::fetch($httpFileIdentifier);
if (!$file instanceof eZHTTPFile) {
$errors[] = array('description' => ezpI18n::tr('kernel/content/upload', 'Expected a eZHTTPFile object but got nothing.'));
return false;
}
$mimeData = eZMimeType::findByFileContents($file->attribute("original_filename"));
return false;
}
function fetchCollectionAttributeHTTPInput($collection, $collectionAttribute, $http, $base, $contentObjectAttribute)
{
EnhancedeZBinaryFileType::checkFileUploads();
if (eZHTTPFile::canFetch($base . "_data_enhancedbinaryfilename_" . $contentObjectAttribute->attribute("id")) != eZHTTPFile::UPLOADEDFILE_OK) {
return false;
}
//Check allowed file type - must do it here,again - otherwise an illegal
//file will still be created in the storage directory
$binaryFile = eZHTTPFile::fetch($base . "_data_enhancedbinaryfilename_" . $contentObjectAttribute->attribute("id"));
if (!$binaryFile) {
return eZInputValidator::STATE_INVALID;
}
$moduleINI = eZINI::instance('module.ini.append.php', 'settings');
$allowed = $moduleINI->variable('AllowedFileTypes', 'AllowedFileTypeList');
// $binaryFile->attribute( 'mime_type_part' ) not always the extension
$extension = preg_replace('/.*\\.(.+?)$/', '\\1', $binaryFile->attribute("original_filename"));
if (!in_array(strtolower($extension), $allowed)) {
$contentObjectAttribute->setValidationError(ezpI18n::tr('kernel/classes/datatypes', 'Failed to store file. Only the following file types are allowed: %1.'), implode(", ", $allowed));
return eZInputValidator::STATE_INVALID;
}
//$contentObjectAttribute->setContent( $binaryFile );
if ($binaryFile instanceof eZHTTPFile) {
//clean up older files.
$moduleINI = eZINI::instance('module.ini.append.php', 'settings');
$maxFiles = $moduleINI->variable('RemoveFiles', 'MaxFiles');
$downloadPath = $moduleINI->variable('RemoveFiles', 'DownloadPath');
$downloadPath = trim($downloadPath, "/");
if (!$downloadPath) {
$downloadPath = 'original/collected';
}
if ($maxFiles > 0) {
$Files = array();
$storageDir = eZSys::storageDirectory();
$fileCollection = eZDir::recursiveFindRelative($storageDir, $downloadPath, '.*');
if (count($fileCollection) >= $maxFiles) {
foreach ($fileCollection as $fileItem) {
$lastModified = filemtime($storageDir . '/' . $fileItem);
$Files[$fileItem] = filemtime($storageDir . '/' . $fileItem);
}
asort($Files, SORT_NUMERIC);
while (count($Files) >= $maxFiles) {
$removeFile = key($Files);
if (file_exists($storageDir . '/' . $removeFile)) {
if (!unlink($storageDir . '/' . $removeFile)) {
eZDebug::writeError("Failed to delete file: " . $storageDir . '/' . $removeFile, "EnhancedeZBinaryFileType");
return false;
}
}
array_shift($Files);
}
}
}
//end cleanup
// $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
//$version = $contentObjectAttribute->attribute( "version" );
$mimeData = eZMimeType::findByFileContents($binaryFile->attribute("original_filename"));
//Nice name but it still uses the extension to set the mimetype and therefore can be bogus
$mime = $mimeData['name'];
if ($mime == '') {
$mime = $binaryFile->attribute("mime_type");
}
$extension = eZFile::suffix($binaryFile->attribute("original_filename"));
$binaryFile->setMimeType($mime);
if (!$binaryFile->store($downloadPath, $extension)) {
eZDebug::writeError("Failed to store http-file: " . $binaryFile->attribute("original_filename"), "EnhancedeZBinaryFileType");
return false;
}
//Adds xmltext to collection attribute with file info to data_text attribute
$doc = new DOMDocument('1.0', 'utf-8');
$root = $doc->createElement('binaryfile-info');
$binaryFileList = $doc->createElement('binaryfile-attributes');
foreach ($binaryFile as $key => $binaryFileItem) {
$binaryFileElement = $doc->createElement($key, $binaryFileItem);
$binaryFileList->appendChild($binaryFileElement);
}
$root->appendChild($binaryFileList);
$doc->appendChild($root);
$docText = EnhancedeZBinaryFileType::domString($doc);
$collectionAttribute->setAttribute('data_text', $docText);
}
return true;
}
