*/
/**
* Load the parent class
*/
GalleryCoreApi::relativeRequireOnce('modules/core/classes/GalleryItem.class');
/**
* A subclass of GalleryItem for items containing actual data
*
* DataItems are ones that have an actual data source, such as
* PhotoItem or MovieItem.
*
* @g2 GalleryDataItem
* @g2 GalleryItem
* @g2
* @g2 1
* @g2 0
* @g2
* @g2
*
* @package GalleryCore
* @subpackage Classes
*/
class GalleryDataItem_core extends GalleryItem {
/*
* ****************************************
* Members
* ****************************************
*/
/**
* The mime type of the data file
*
* @g2
* @g2 mimeType
* @g2 STRING
* @g2 MEDIUM
* @g2
* @g2
*
* @var string $_mimeType
* @access private
*/
var $_mimeType;
/**
* The byte size of the data file
*
* @g2
* @g2 size
* @g2 INTEGER
* @g2
* @g2
*
* @var string $_size
* @access private
*/
var $_size;
/*
* ****************************************
* Methods
* ****************************************
*/
/**
* Data items that can be viewed inline (photos, movies, etc) should return
* true. Items that can't be viewed inline (word documents, text, etc)
* should return false.
*
* Classes that return true for this query must implement getWidth() and getHeight()
*
* @return boolean true if this data item can be viewed inline
*/
function canBeViewedInline() {
return false;
}
/**
* Create a new instance of this type in the persistent store.
*
* @access public
* @param int the id of the parent GalleryItem
* @param string the path to a data file to be contained
* @param string the mime type of the new item
* @param string (optional) the desired name of the new item
* @param boolean (optional) a boolean true if we should symlink instead
* of copy (default is false).
* @return object GalleryStatus a status code
*/
function create($parentId, $inputFileName, $mimeType, $targetName=null, $symlink=false) {
global $gallery;
$platform = $gallery->getPlatform();
/* Validate the input file */
if (empty($inputFileName)) {
return GalleryStatus::error(ERROR_BAD_PARAMETER, __FILE__, __LINE__);
}
if (!$platform->is_uploaded_file($inputFileName)
&& !$platform->file_exists($inputFileName)) {
return GalleryStatus::error(ERROR_BAD_PATH, __FILE__, __LINE__);
}
/*
* The parent must be read locked at this point to make sure that it's
* not going to be moved around while we're adding stuff to it.
*/
if (!GalleryCoreApi::isReadLocked($parentId)) {
return GalleryStatus::error(ERROR_LOCK_REQUIRED, __FILE__, __LINE__);
}
/* Set the mime type before we call the parent so that it can use this info if necessary */
$this->setMimeType($mimeType);
$baseName = !empty($targetName) ? $targetName : basename($inputFileName);
$ret = parent::create($parentId, $baseName);
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
/* Figure out the new location for this file */
list($ret, $parent) = GalleryCoreApi::loadEntitiesById($parentId);
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
list($ret, $parentPath) = $parent->fetchContainerPath();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
/*
* Grab the new name from the path component, since GalleryFileSystemEntity
* may adapt the newName to avoid conflicts
*/
$newFileName = $parentPath . $this->getPathComponent();
/*
* XXX: Race condition here! It's possible for two threads to be
* adding a file with the same name to the container at the same time.
* We have to write lock the container to be sure that this doesn't
* happen.
*/
if ($symlink) {
if (!$platform->isSymlinkSupported()) {
return GalleryStatus::error(ERROR_UNSUPPORTED_OPERATION, __FILE__, __LINE__);
}
if (!$platform->symlink($inputFileName, $newFileName)) {
return GalleryStatus::error(ERROR_PLATFORM_FAILURE, __FILE__, __LINE__);
}
} else {
/* Copy the file to its new location */
if (!$platform->copy($inputFileName, $newFileName)) {
return GalleryStatus::error(ERROR_PLATFORM_FAILURE, __FILE__, __LINE__);
}
}
/* Set my file size */
$this->setSize($platform->filesize($newFileName));
return GalleryStatus::success();
}
/**
* @see GalleryEntity::detachLink
*/
function detachLink() {
global $gallery;
/* Stash the linked entity because the super class is going to get rid of it */
$linkedEntity = $this->getLinkedEntity();
$ret = parent::detachLink();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
$platform = $gallery->getPlatform();
list ($ret, $sourcePath) = $linkedEntity->fetchPath();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
list ($ret, $parent) = $this->fetchParent();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
list ($ret, $newPathBase) = $parent->fetchContainerPath();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
/* This path should already be legal, unless we screwed up elsewhere */
$newPath = $newPathBase . $this->getPathComponent();
if (!$platform->copy($sourcePath, $newPath)) {
return GalleryStatus::error(ERROR_PLATFORM_FAILURE, __FILE__, __LINE__);
}
return GalleryStatus::success();
}
/**
* Delete this GalleryEntity
*
* @access public
* @return object GalleryStatus a status code
*/
function delete() {
global $gallery;
/* TODO: Check for derivative relationships and expire as necessary. */
/* Delete myself */
$ret = parent::delete();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
/* Delete our source file, if we're not a link */
if (!$this->isLinked()) {
list($ret, $path) = $this->fetchPath();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
$platform = $gallery->getPlatform();
if ($platform->file_exists($path) && !$platform->unlink($path)) {
return GalleryStatus::error(ERROR_BAD_PATH, __FILE__, __LINE__,
"Could not delete $path");
}
}
return GalleryStatus::success();
}
/**
* Scan this item's data for changes.
*
* @return object GalleryStatus a status code
*/
function rescan() {
global $gallery;
$platform = $gallery->getPlatform();
list($ret, $path) = $this->fetchPath();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
$this->setSize($platform->filesize($path));
return GalleryStatus::success();
}
/**
* Rename this DataItem
*
* @access public
* @param string the path component
* @return object GalleryStatus a status code
*/
function rename($newName) {
global $gallery;
if ($newName == $this->getPathComponent()) {
return GalleryStatus::success();
}
/*
* Read lock the parent so that we don't have a race condition below.
*/
list ($ret, $lockId) = GalleryCoreApi::acquireReadLock($this->getParentId());
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
$platform = $gallery->getPlatform();
/*
* Get the current path before we let the superclass do the rename
*/
list($ret, $currentPath) = $this->fetchPath();
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
/*
* Set the new path in the database. If that succeeds then we should
* be ok in general. Jump through hoops to make sure that we release
* our locks at the end.
*/
$error = null;
$ret = parent::rename($newName);
if ($ret->isError()) {
$error = $ret->wrap(__FILE__, __LINE__);
}
/* Only rename the filesystem entity if we're not a link */
if (!$this->isLinked()) {
/*
* Grab the new name from the path component, since GalleryFileSystemEntity
* may adapt the newName to avoid conflicts
*/
$newName = $this->getPathComponent();
if (!isset($error)) {
$newPath = dirname($currentPath) . '/' . $newName;
/* Check to see if the desired path exists. */
if ($platform->file_exists($newPath)) {
$error = GalleryStatus::error(ERROR_COLLISION, __FILE__, __LINE__);
}
}
if (!isset($error)) {
if (!$platform->rename($currentPath, $newPath)) {
$error = GalleryStatus::error(ERROR_BAD_PATH, __FILE__, __LINE__);
}
}
}
/* Release locks */
$ret = GalleryCoreApi::releaseLocks($lockId);
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
if (isset($error)) {
return $error;
}
return GalleryStatus::success();
}
/**
* Move this item to a new parent
*
* @param int the id of the GalleryItem parent
* @return object GalleryStatus a status code
*/
function move($newParentId) {
/* Get the current parent sequence */
list ($ret, $parentSequence) = GalleryCoreApi::fetchParentSequence($this->getId());
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
$ret = parent::move($newParentId);
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
/* Set the new parent sequence */
list ($ret, $newParentSequence) = GalleryCoreApi::fetchParentSequence($this->getParentId());
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
$newParentSequence[] = $this->getParentId();
/* Set my parent sequence accordingly */
$ret = GalleryCoreApi::setParentSequence($this->getId(), $newParentSequence);
if ($ret->isError()) {
return $ret->wrap(__FILE__, __LINE__);
}
return GalleryStatus::success();
}
/**
* Get the full path to the data file.
*
* @access public
* @return array object GalleryStatus a status code,
* string a path where children can store their data files
*/
function fetchPath() {
global $gallery;
/*
* Source files in the item's directory. But the parent may be an item
* that doesn't have its own directory, so we need to get the path of
* the nearest parent who is a container (eg an AlbumItem), because a
* container has a directory for the items it contains.
*/
if ($this->isLinked()) {
$target = $this->getLinkedEntity();
} else {
$target = $this;
}
list($ret, $containerPath) = $target->fetchContainerPath();
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
return array(GalleryStatus::success(), $containerPath . $target->getPathComponent());
}
/**
* Render this item in the given format. For example, GalleryPhotoItem may want to
* render as an tag in the HTML format, whereas GalleryMovieItem would use
*