Esempio n. 1
0
 /**
  * Regression test for issue #16078
  *
  * @link http://issues.ez.no/16078
  */
 public function testIssue16078()
 {
     $classID = 5;
     // image class, can remain hardcoded, I guess
     $baseImagePath = dirname(__FILE__) . '/ezimagefile_regression_issue16078.png';
     $parts = pathinfo($baseImagePath);
     $imagePattern = $parts['dirname'] . DIRECTORY_SEPARATOR . $parts['filename'] . '_%s_%d.' . $parts['extension'];
     $toDelete = array();
     // Create version 1
     $imagePath = sprintf($imagePattern, md5(1), 1);
     copy($baseImagePath, $imagePath);
     $toDelete[] = $imagePath;
     $image = new ezpObject('image', 43);
     $image->name = __FUNCTION__;
     $image->image = $imagePath;
     $image->publish();
     $image->refresh();
     $publishedDataMap = $image->object->dataMap();
     $files = eZImageFile::fetchForContentObjectAttribute($publishedDataMap['image']->attribute('id'));
     $publishedImagePath = $files[0];
     // Create a new image file
     $imagePath = sprintf($imagePattern, md5(2), 2);
     copy($baseImagePath, $imagePath);
     $toDelete[] = $imagePath;
     // Create version 2 in another language, and remove it
     $languageCode = 'nor-NO';
     $version = self::addTranslationDontPublish($image, $languageCode);
     $version->removeThis();
     // Check that the original file still exists
     $this->assertTrue(file_exists($publishedImagePath), 'The image file from version 1 should still exist when version 2 is removed');
     array_map('unlink', $toDelete);
     $image->purge();
 }
 /**
  * Regression test for issue #14983
  *
  * @link http://issues.ez.no/14983
  **/
 public function testIssue14983()
 {
     $className = 'eZImageType test class';
     $classIdentifier = 'ezimagetype_test_class';
     $attributeName = 'Image';
     $attributeIdentifier = 'image';
     $attributeType = 'ezimage';
     $filePath = 'tests/tests/kernel/datatypes/ezimage/ezimagetype_regression_issue14983.png';
     $class = new ezpClass($className, $classIdentifier, $className);
     $classAttribute = $class->add($attributeName, $attributeIdentifier, $attributeType);
     $class->store();
     $object = new ezpObject($classIdentifier, 2);
     $object->name = __FUNCTION__;
     $dataMap = $object->object->dataMap();
     $fileAttribute = $dataMap[$attributeIdentifier];
     $dataType = new eZImageType();
     $dataType->fromString($fileAttribute, $filePath);
     $fileAttribute->store();
     $object->publish();
     $object->refresh();
     $contentObjectAttributeID = $fileAttribute->attribute("id");
     $files = eZImageFile::fetchForContentObjectAttribute($contentObjectAttributeID);
     $file = $files[0];
     // Read stored path, move to trash, and read stored path again
     $this->assertNotEquals($file, null);
     $oldFile = $file;
     $object->object->removeThis();
     $object->refresh();
     $files = eZImageFile::fetchForContentObjectAttribute($contentObjectAttributeID);
     $file = $files[0];
     $this->assertNotEquals($oldFile, $file, 'The stored file should be renamed when trashed');
 }
Esempio n. 3
0
 /**
  * Regression test for issue #14983
  * Linked to #17781
  *
  * @link http://issues.ez.no/14983
  * @link http://issues.ez.no/17781
  * @group issue14983
  * @group issue17781
  */
 public function testIssue14983()
 {
     $files = eZImageFile::fetchForContentObjectAttribute($this->fileAttribute->attribute("id"), true);
     self::assertInternalType("array", $files);
     $file = $files[0];
     unset($files);
     // Read stored path, move to trash, and read stored path again
     self::assertInstanceOf('eZImageFile', $file);
     $oldFile = $file;
     $this->imageObject->object->removeThis();
     $this->imageObject->refresh();
     $files = eZImageFile::fetchForContentObjectAttribute($this->fileAttribute->attribute("id"), true);
     self::assertInternalType("array", $files);
     $file = $files[0];
     unset($files);
     self::assertInstanceOf('eZImageFile', $file);
     self::assertTrue(strpos($file->attribute("filepath"), '/trashed') !== false, "The stored file should be renamed when trashed");
 }
Esempio n. 4
0
 function trashStoredObjectAttribute($contentObjectAttribute, $version = null)
 {
     $contentObjectAttributeID = $contentObjectAttribute->attribute("id");
     $imageHandler = $contentObjectAttribute->attribute('content');
     $imageFiles = eZImageFile::fetchForContentObjectAttribute($contentObjectAttributeID);
     foreach ($imageFiles as $imageFile) {
         if ($imageFile == null) {
             continue;
         }
         $existingFilepath = $imageFile;
         // Check if there are any other records in ezimagefile that point to that filename.
         $imageObjectsWithSameFileName = eZImageFile::fetchByFilepath(false, $existingFilepath);
         $file = eZClusterFileHandler::instance($existingFilepath);
         if ($file->exists() and count($imageObjectsWithSameFileName) <= 1) {
             $orig_dir = dirname($existingFilepath) . '/trashed';
             $fileName = basename($existingFilepath);
             // 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
             $newFileBaseName = md5($fileBaseName . microtime() . mt_rand());
             $newFileName = $newFileBaseName . $fileSuffix;
             $newFilepath = $orig_dir . '/' . $newFileName;
             // rename the file, and update the database data
             $imageHandler->updateAliasPath($orig_dir, $newFileBaseName);
             if ($imageHandler->isStorageRequired()) {
                 $imageHandler->store($contentObjectAttribute);
                 $contentObjectAttribute->store();
             }
         }
     }
 }
Esempio n. 5
0
 /**
  * Removes all image alias files which the attribute refers to.
  *
  * @param eZContentObjectAttribute
  * @note If you want to remove the alias information use removeAliases().
  */
 static function removeAllAliases($contentObjectAttribute)
 {
     $handler = $contentObjectAttribute->attribute('content');
     if (!$handler->isImageOwner()) {
         return;
     }
     $attributeData = $handler->originalAttributeData();
     $files = eZImageFile::fetchForContentObjectAttribute($attributeData['attribute_id'], false);
     $dirs = array();
     foreach ($files as $filepath) {
         $file = eZClusterFileHandler::instance($filepath);
         if ($file->exists()) {
             $file->fileDelete($filepath);
             $dirs[] = eZDir::dirpath($filepath);
         }
     }
     $dirs = array_unique($dirs);
     foreach ($dirs as $dirpath) {
         eZDir::cleanupEmptyDirectories($dirpath);
     }
     eZImageFile::removeForContentObjectAttribute($attributeData['attribute_id']);
 }
Esempio n. 6
0
 /**
  * Attempt to remove content object 'image' attribute image variations by content object attribute
  *
  * @param object $contentClassImageAttribute object of objects of class eZContentObjectAttribute
  * @param array $class Array of object class identifiers to remove aliases for only these classes. Optional. Defaults to false
  * @param array $attributes Array of object image attribute identifiers to remove aliases from. Optional. Defaults to false
  * @param array $aliases Array of object image attribute image aliases to remove. Optional. Defaults to false
  *
  * @return bool true if successful, false otherwise
  * @static
  */
 static function removeByAttribute($contentObjectAttribute = false, $classes = false, $attributes = false, $aliases = false)
 {
     if (!is_object($contentObjectAttribute)) {
         return false;
     }
     // Test that content object class attribute identifier matches provided classes
     if ($classes != false && is_array($classes) && !in_array($contentObjectAttribute->attribute('object')->attribute('class_identifier'), $classes)) {
         return false;
     }
     // Test that content object class attribute identifier matches provided classes
     if ($attributes != false && is_array($attributes) && !in_array($contentObjectAttribute->attribute('contentclass_attribute_identifier'), $attributes)) {
         return false;
     }
     // Default datatypes to create image alias variations
     $imageDataTypeStrings = eZINI::instance('bcimagealias.ini')->variable('BCImageAliasSettings', 'ImageDataTypeStringList');
     // Check that content object attribute data type string matches allowed datatype settings
     if (!in_array($contentObjectAttribute->attribute('data_type_string'), $imageDataTypeStrings) || !$contentObjectAttribute->attribute('has_content')) {
         return false;
     }
     $filePaths = array();
     $results = array();
     $executionOptions = self::executionOptions();
     $messageCount = 0;
     $imageHandler = $contentObjectAttribute->attribute('content');
     $aliasList = $imageHandler->aliasList(false);
     // Do not process the orginal image alias
     unset($aliasList['original']);
     if (count($aliasList) == 0) {
         return false;
     }
     // Optional debug output
     if ($executionOptions['troubleshoot'] && $executionOptions['verboseLevel'] >= 2) {
         if ($executionOptions['verboseLevel'] >= 3) {
             self::displayMessage('All attribute image aliases stored in content data text field:', false);
             self::displayMessage($contentObjectAttribute->attribute('data_text'), "\n");
         }
         if ($executionOptions['verboseLevel'] >= 4) {
             self::displayMessage('All attribute image aliases stored in content alias list:', false);
             print_r($aliasList);
             self::displayMessage('', "\n\n");
         } elseif ($executionOptions['verboseLevel'] >= 3) {
             self::displayMessage('All attribute image aliases stored in content alias list:', false);
             print_r(array_keys($aliasList));
             self::displayMessage('', "\n");
         }
     }
     $contentObjectID = $contentObjectAttribute->attribute('contentobject_id');
     $contentObjectAttributeID = $contentObjectAttribute->attribute('id');
     $contentObjectAttributeVersion = $contentObjectAttribute->attribute('version');
     if ($contentObjectAttributeVersion === null) {
         $files = eZImageFile::fetchForContentObjectAttribute($contentObjectAttributeID, true);
         $dirs = array();
         $count = 0;
         // Iterate over files
         foreach ($files as $filepath) {
             // Test $filepath from $files is in contains one of the $aliases items
             if ($aliases != false && is_array($aliases)) {
                 foreach ($aliases as $alias) {
                     if (!stristr('_' . $alias, $filepath)) {
                         continue 1;
                     }
                 }
             }
             $file = eZClusterFileHandler::instance($filepath);
             if ($file->exists()) {
                 $filePaths[] = $filepath;
                 if (!$executionOptions['dry']) {
                     $file->fileDelete($filepath);
                     $dirs[] = eZDir::dirpath($filepath);
                 }
                 $count++;
             }
         }
         if (!$executionOptions['dry']) {
             $dirs = array_unique($dirs);
             foreach ($dirs as $dirpath) {
                 eZDir::cleanupEmptyDirectories($dirpath);
             }
             eZImageFile::removeForContentObjectAttribute($contentObjectAttributeID);
             $message = "Removed datatype " . $contentObjectAttribute->attribute('data_type_string') . "type image alias variation " . $filePaths[$messageCount] . "\n";
         } else {
             $message = "Dry run: Remove datatype " . $contentObjectAttribute->attribute('data_type_string') . "type image alias variation " . $filePaths[$messageCount] . "\n";
         }
         while ($messageCount < $count) {
             self::scriptIterate($message);
             $messageCount++;
             $result = true;
         }
     } else {
         // We loop over each image alias, and look up the file in ezcontentobject_attribute
         // Only images referenced by one version will be removed
         foreach ($aliasList as $aliasName => $aliasListAliasItem) {
             // Test $aliasListAliasItem from $aliasList is in $aliases array
             if ($aliases != false && is_array($aliases) && !in_array($aliasListAliasItem['name'], $aliases)) {
                 continue;
             }
             if ($aliasListAliasItem['is_valid'] && $aliasListAliasItem['name'] != 'original') {
                 $filepath = $aliasListAliasItem['url'];
                 // Calculate appropriate message to Alert user with
                 if (!$executionOptions['dry']) {
                     // Remove the alias variation image file from the attribute dom tree
                     $doc = $imageHandler->ContentObjectAttributeData['DataTypeCustom']['dom_tree'];
                     foreach ($doc->getElementsByTagName('alias') as $aliasNode) {
                         if ($aliasListAliasItem['name'] == $aliasNode->getAttribute('name')) {
                             // Optional debug output
                             if ($executionOptions['troubleshoot']) {
                                 self::displayMessage('Removing image alias image variation ' . "'" . $aliasNode->getAttribute('name') . "'" . ' from attribute dom document');
                             }
                             $aliasNode->parentNode->removeChild($aliasNode);
                         }
                     }
                     $imageHandler->ContentObjectAttributeData['DataTypeCustom']['dom_tree'] = $doc;
                     unset($imageHandler->ContentObjectAttributeData['DataTypeCustom']['alias_list']);
                     $imageHandler->storeDOMTree($doc, true, $contentObjectAttribute);
                 }
                 // Calculate appropriate message to Alert user with
                 if ($executionOptions['dry']) {
                     $message = "Dry run: Calculating removal of datatype " . $contentObjectAttribute->attribute('data_type_string') . "type image alias variation file " . $filepath;
                 } else {
                     $message = "Removed standard datatype " . $contentObjectAttribute->attribute('data_type_string') . "type image alias variation file " . $filepath;
                 }
                 if (!$executionOptions['dry']) {
                     $dirpath = $aliasListAliasItem['dirpath'];
                     $file = eZClusterFileHandler::instance($filepath);
                     if ($file->exists()) {
                         $file->purge();
                         eZImageFile::removeFilepath($contentObjectAttributeID, $filepath);
                         eZDir::cleanupEmptyDirectories($dirpath);
                         self::scriptIterate($message);
                         $results[] = true;
                     } else {
                         eZDebug::writeError("Image file {$filepath} for alias {$aliasName} does not exist, could not remove from disk", __METHOD__);
                         self::displayMessage("Image file {$filepath} for alias {$aliasName} does not exist, could not remove from disk: " . __METHOD__);
                     }
                     eZContentCacheManager::clearContentCacheIfNeeded($contentObjectID);
                 } else {
                     self::scriptIterate($message);
                     $results[] = true;
                 }
             }
         }
     }
     // Calculate return results based on execution options and results comparison
     if (in_array(true, $results) && count($aliasList) == count($results) && !$executionOptions['dry']) {
         return true;
     }
     return false;
 }