/**
* For a provided type and id, return the path to the original for loading and saving purposes
*
* @param int $imageType One of ISC_PICNIK_TYPE_ constants
* @param mixed $imageId Image identifier (could be numeric for product images, filename for image manager, etc.)
* @return string
*/
public function getSourceFileForImage($imageType, $imageId)
{
switch ($imageType) {
case ISC_PICNIK_TYPE_PRODUCTIMAGE:
try {
$image = new ISC_PRODUCT_IMAGE((int)$imageId);
} catch (Exception $exception) {
return false;
}
return $image->getAbsoluteSourceFilePath();
break;
case ISC_PICNIK_TYPE_IMAGEMANAGER:
return ISC_BASE_PATH . '/' . GetConfig('ImageDirectory') . '/uploaded_images/' . rawurlencode($imageId);
break;
}
}
/**
* Imports a temporary image file on the server to the given product. Performs validation, moves the file to it's final location and filename and returns an instance of ISC_PRODUCT_IMAGE.
*
* It is up to the method calling this to delete any temporary file if something goes wrong.
*
* @param string $temporaryPath Absolute path to the temporary image file stored on the server to be imported -- this file will need to be read so if it is an uploaded file and is in the tmp folder you should move it to the cache directory first since open_basedir restrictions may prevent the file being read from the tmp folder
* @param string $originalFilename Original intended filename (such as the name provided by the browser when uploading a file) which may differ from the temporary file at $temporaryPath -- this should not include any directory components
* @param int|string|bool $productId The id (or hash when $hash is true) of the product to import to, or supply as false to not save any info to the database but still return an instance of ISC_PRODUCT_IMAGE
* @param bool $hash If true, $productId will be treated as a hash of a product in the process of being added
* @param bool $moveTemporaryFile If true, the provided temporary file will be moved to it's new location, otherwise it will be copied
* @param bool $generateImages If true, when importing, will attempt to generate thumbnail images -- may not be desirable if importing many images at once
* @throws ISC_PRODUCT_IMAGE_IMPORT_INVALIDIMAGEFILE_EXCEPTION If the file is not a valid image
* @throws ISC_PRODUCT_IMAGE_IMPORT_NOPHPSUPPORT_EXCEPTION If the image could not be processed by any installed php extensions
* @throws ISC_PRODUCT_IMAGE_IMPORT_EMPTYIMAGE_EXCEPTION If the image is 'empty' - has 0 width or 0 height
* @throws ISC_PRODUCT_IMAGE_IMPORT_CANTCREATEDIR_EXCEPTION If an error prevented the image's destination directory from being created (usually lack of write permissions on parent directory)
* @throws ISC_PRODUCT_IMAGE_IMPORT_CANTMOVEFILE_EXCEPTION If an error prevented the image from being moved to the destination directory (usually lack of write permissions on parent directory)
* @return ISC_PRODUCT_IMAGE If everything went OK
*/
public static function importImage($temporaryPath, $originalFilename, $productId, $hash = false, $moveTemporaryFile = true, $generateImages = true)
{
if (!file_exists($temporaryPath)) {
throw new ISC_PRODUCT_IMAGE_SOURCEFILEDOESNTEXIST_EXCEPTION($temporaryPath);
}
try {
$library = ISC_IMAGE_LIBRARY_FACTORY::getImageLibraryInstance($temporaryPath);
} catch (ISC_IMAGE_LIBRARY_FACTORY_INVALIDIMAGEFILE_EXCEPTION $ex) {
throw new ISC_PRODUCT_IMAGE_IMPORT_INVALIDIMAGEFILE_EXCEPTION();
} catch (ISC_IMAGE_LIBRARY_FACTORY_NOPHPSUPPORT_EXCEPTION $ex) {
throw new ISC_PRODUCT_IMAGE_IMPORT_NOPHPSUPPORT_EXCEPTION();
}
if ($library->getWidth() < 1 || $library->getHeight() < 1) {
throw new ISC_PRODUCT_IMAGE_IMPORT_EMPTYIMAGE_EXCEPTION();
}
$finalName = $originalFilename;
$finalName = basename($finalName); // remove any path components from the filename
$finalName = self::sanitiseFilename($finalName);
if (!self::isValidFilename($finalName, false)) {
throw new ISC_PRODUCT_IMAGE_IMPORT_INVALIDFILENAME_EXCEPTION($finalName);
}
// correct the uploaded extension
$correctExtension = $library->getImageTypeExtension(false);
if (strtolower(pathinfo($finalName, PATHINFO_EXTENSION)) != $correctExtension) {
// remove existing extension and trailing . if any
$finalName = preg_replace('#\.[^\.]*$#', '', $finalName);
// add correct extension
$finalName .= '.' . $correctExtension;
}
// generate a path for storing in the product_images directory
$finalRelativePath = self::generateSourceImageRelativeFilePath($finalName);
$image = new ISC_PRODUCT_IMAGE();
$image->setSourceFilePath($finalRelativePath);
$finalAbsolutePath = $image->getAbsoluteSourceFilePath();
$finalDirectory = dirname($finalAbsolutePath);
if (!file_exists($finalDirectory)) {
if (!isc_mkdir($finalDirectory, ISC_WRITEABLE_DIR_PERM, true)) {
throw new ISC_PRODUCT_IMAGE_IMPORT_CANTCREATEDIR_EXCEPTION($finalDirectory);
}
}
if ($moveTemporaryFile) {
if (!@rename($temporaryPath, $finalAbsolutePath)) {
throw new ISC_PRODUCT_IMAGE_IMPORT_CANTMOVEFILE_EXCEPTION($finalAbsolutePath);
}
} else {
if (!@copy($temporaryPath, $finalAbsolutePath)) {
throw new ISC_PRODUCT_IMAGE_IMPORT_CANTMOVEFILE_EXCEPTION($finalAbsolutePath);
}
}
// check to see if the uploaded image exceeds our internal maximum image size: ISC_PRODUCT_IMAGE_MAXLONGEDGE
if ($library->getWidth() > ISC_PRODUCT_IMAGE_MAXLONGEDGE || $library->getHeight() > ISC_PRODUCT_IMAGE_MAXLONGEDGE) {
// if it is, resize it and overwrite the uploaded source image because we only want to store images to a maximum size of ISC_PRODUCT_IMAGE_MAXLONGEDGE x ISC_PRODUCT_IMAGE_MAXLONGEDGE
$library->setFilePath($finalAbsolutePath);
$library->loadImageFileToScratch();
$library->resampleScratchToMaximumDimensions(ISC_PRODUCT_IMAGE_MAXLONGEDGE, ISC_PRODUCT_IMAGE_MAXLONGEDGE);
$library->saveScratchToFile($finalAbsolutePath, self::getWriteOptionsForImageType($library->getImageType()));
}
if ($productId === false) {
// do not assign product hash, id or save to database if $productId is false
if ($generateImages) {
// manually generate images since, normally, a call to saveToDatabase would do it
$image->getResizedFileDimensions(ISC_PRODUCT_IMAGE_SIZE_TINY, true, false);
$image->getResizedFileDimensions(ISC_PRODUCT_IMAGE_SIZE_THUMBNAIL, true, false);
$image->getResizedFileDimensions(ISC_PRODUCT_IMAGE_SIZE_STANDARD, true, false);
$image->getResizedFileDimensions(ISC_PRODUCT_IMAGE_SIZE_ZOOM, true, false);
}
return $image;
}
if ($hash) {
$image->setProductHash($productId);
} else {
$image->setProductId($productId);
}
// ISC_PRODUCT_IMAGE_SOURCEFILEDOESNTEXIST_EXCEPTION should never really happen at this point with all the checks above so, if it does, let the exception go unhandled to bubble up to a fatal error
$image->saveToDatabase($generateImages);
return $image;
}
/**
* Handler for accepting a new product images from the image manager or other products
*
* @param ISC_ADMIN_REMOTE $remote
*/
public function remoteUseSourceImages(ISC_ADMIN_REMOTE $remote)
{
GetLib('class.imagedir');
$db = $GLOBALS["ISC_CLASS_DB"];
$sourceImages = @$_POST['images'];
$tags = array();
$errors = array();
$images = array();
$productId = false;
$productHash = false;
if (isset($_POST['product'])) {
$productId = (int)@$_POST['product'];
if (!isId($productId) || !ProductExists($productId)) {
$errors[] = GetLang('ProductDoesntExist');
}
} else if (isset($_POST['hash']) && $_POST['hash']) {
$productHash = $_POST['hash'];
} else {
$errors[] = GetLang('ProductDoesntExist');
}
if (empty($errors) && count($sourceImages)) {
// only proceed if they had images selected
$imageDir = new ISC_IMAGEDIR();
foreach ($sourceImages as $imageId) {
if(substr($imageId, 0, strlen('productimage_')) == 'productimage_') {
// image from another product
$productImageId = (int)str_replace('productimage_', '', $imageId);
$productImage = new ISC_PRODUCT_IMAGE($productImageId);
$sourceFilePath = $productImage->getAbsoluteSourceFilePath();
$originalFilename = $productImage->getFileName();
} elseif (substr($imageId, 0, strlen('imagemanager_')) == 'imagemanager_') {
// image from the image manager
$imageManagerId = str_replace('imagemanager_', '', $imageId);
$originalFilename = $imageDir->findFileNameById($imageManagerId);
$sourceFilePath = $imageDir->GetImagePath() . '/' . $originalFilename;
} else {
// not a valid selection
continue;
}
try {
if ($productHash) {
$image = ISC_PRODUCT_IMAGE::importImage($sourceFilePath, $originalFilename, $productHash, true, false);
} else {
$image = ISC_PRODUCT_IMAGE::importImage($sourceFilePath, $originalFilename, $productId, false, false);
}
} catch (ISC_PRODUCT_IMAGE_IMPORT_INVALIDIMAGEFILE_EXCEPTION $exception) {
$errors[] = $url . ": " . $exception->getMessage() . ' ' . GetLang('ProductImageInvalidFileFromSource');
continue;
} catch (ISC_PRODUCT_IMAGE_IMPORT_EXCEPTION $exception) {
// these exceptions should have language-powered messages so are safe to return to the user
$errors[] = $url . ": " . $exception->getMessage();
continue;
} catch (Exception $exception) {
// other unknown error
$errors[] = $url . ': ' . GetLang('ProductImageProcessUnknownError');
continue;
}
// all done, add to list of successful images
$images[] = $image;
}
}
foreach ($images as /*ISC_PRODUCT_IMAGE*/$image) {
$json = array(
'id' => $image->getProductImageId(),
'product' => $image->getProductId(),
'hash' => $image->getProductHash(),
'preview' => $image->getResizedUrl(ISC_PRODUCT_IMAGE_SIZE_THUMBNAIL, true),
'zoom' => $image->getResizedUrl(ISC_PRODUCT_IMAGE_SIZE_ZOOM, true),
'description' => $image->getDescription(),
'baseThumbnail' => $image->getIsThumbnail(),
'sort' => $image->getSort(),
);
$tags[] = $remote->MakeXMLTag('image', isc_json_encode($json), true);
}
foreach ($errors as $message) {
$tags[] = $remote->MakeXMLTag('error', $message, true);
}
$remote->SendXMLHeader();
$remote->SendXMLResponse($tags);
die();
}