/**
* Uploads the given file to a temporary location on the site.
*
* @since 1.0
* @access public
* @param string
* @return string The path to the uploaded item.
*/
public function upload($file, $hash, $userId)
{
// Check if file exists on the server
if (!isset($file['tmp_name']) || empty($file)) {
$this->setError(JText::_('COM_EASYSOCIAL_UPLOADER_FILE_NOT_FOUND'));
return false;
}
// Lets figure out the storage path.
$config = FD::config();
// Test if the folder exists for this upload type.
$path = JPATH_ROOT . '/' . FD::cleanPath($config->get('uploader.storage.container'));
if (!FD::makeFolder($path)) {
$this->setError(JText::sprintf('COM_EASYSOCIAL_UPLOADER_UNABLE_TO_CREATE_DESTINATION_FOLDER', $path));
return false;
}
// Let's finalize the storage path.
$storage = $path . '/' . $userId;
if (!FD::makeFolder($storage)) {
$this->setError(JText::sprintf('COM_EASYSOCIAL_UPLOADER_UNABLE_TO_CREATE_DESTINATION_FOLDER', $storage));
return false;
}
// Once the script reaches here, we assume everything is good now.
// Copy the files over.
jimport('joomla.filesystem.file');
$absolutePath = $storage . '/' . $hash;
if (!JFile::copy($file['tmp_name'], $absolutePath)) {
$this->setError(JText::sprintf('COM_EASYSOCIAL_UPLOADER_UNABLE_TO_COPY_TO_DESTINATION_FOLDER', $absolutePath));
return false;
}
return $absolutePath;
}
public static function getStoragePath($inputName, $overwrite = true)
{
// Create a temporary folder for this session.
$session = JFactory::getSession();
$uid = md5($session->getId() . $inputName);
$path = SOCIAL_MEDIA . '/tmp/' . $uid . '_avatar';
if ($overwrite) {
// If the folder exists, delete them first.
if (JFolder::exists($path)) {
JFolder::delete($path);
}
// Create folder if necessary.
FD::makeFolder($path);
}
return $path;
}
/**
* Responsible to store the uploaded images.
*
* @since 1.0
* @access public
* @param null
*
* @author Mark Lee <*****@*****.**>
*/
public function upload($file)
{
// Get config object.
$config = FD::config();
// Do not proceed if image doesn't exist.
if (empty($file) || !isset($file['tmp_name'])) {
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_AVATARS_FILE_UNAVAILABLE'));
return false;
}
// Get the default avatars storage location.
$avatarsPath = JPATH_ROOT . '/' . FD::cleanPath($config->get('avatars.storage.container'));
// Test if the avatars path folder exists. If it doesn't we need to create it.
if (!FD::makeFolder($avatarsPath)) {
$this->setError(JText::_('Errors when creating default container for avatar'));
return false;
}
// Get the default avatars storage location for this type.
$typePath = $config->get('avatars.storage.' . $this->type);
$storagePath = $avatarsPath . '/' . FD::cleanPath($typePath);
// Ensure storage path exists.
if (!FD::makeFolder($storagePath)) {
$this->setError(JText::_('Errors when creating path for avatar'));
return false;
}
// Get the profile id and construct the final path.
$idPath = FD::cleanPath($this->uid);
$storagePath = $storagePath . '/' . $idPath;
// Ensure storage path exists.
if (!FD::makeFolder($storagePath)) {
$this->setError(JText::_('Errors when creating default path for avatar'));
return false;
}
// Get the image library to perform some checks.
$image = FD::get('Image');
$image->load($file['tmp_name']);
// Test if the image is really a valid image.
if (!$image->isValid()) {
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_AVATARS_FILE_NOT_IMAGE'));
return false;
}
// Process avatar storage.
$avatar = FD::get('Avatar', $image);
// Let's create the avatar.
$sizes = $avatar->create($storagePath);
if ($sizes === false) {
$this->setError(JText::_('Sorry, there was some errors when creating the avatars.'));
return false;
}
// Delete previous files.
$this->deleteFile($storagePath);
// Assign the values back.
foreach ($sizes as $size => $url) {
$this->{$size} = $url;
}
return true;
}
private function processDiscussionFiles()
{
$db = FD::db();
$sql = $db->sql();
$query = 'select a.*, d.`uid` as `esdiscussid`, c.`uid` as `esgroupid`, e.`uid` as `escollectid`';
$query .= ' from `#__community_files` as a';
$query .= ' inner join `#__social_migrators` as c on a.`groupid` = c.`oid` and c.`element` = ' . $db->Quote('groups') . ' and c.`component` = ' . $db->Quote($this->name);
$query .= ' inner join `#__social_migrators` as d on a.discussionid = d.oid and d.`element` = ' . $db->Quote('groupdiscussionsparent') . ' and d.`component` = ' . $db->Quote($this->name);
$query .= ' left join `#__social_migrators` as e on a.groupid = e.oid and e.`element` = ' . $db->Quote('groupcollection') . ' and e.`component` = ' . $db->Quote($this->name);
$query .= ' where not exists ( ';
$query .= ' select b.`id` from `#__social_migrators` as b';
$query .= ' where a.`id` = b.`oid` and b.`element` = ' . $db->Quote('groupdiscussionsfile') . ' and b.`component` = ' . $db->Quote($this->name);
$query .= ' )';
$query .= ' ORDER BY a.`id` ASC';
$sql->raw($query);
$db->setQuery($sql);
$jsFiles = $db->loadObjectList();
if (count($jsFiles) <= 0) {
return null;
}
foreach ($jsFiles as $jsFile) {
$esCollectionId = $this->getGroupCollectionId($jsFile);
$filePath = JPATH_ROOT . '/' . $jsFile->filepath;
if (JFile::exists($filePath)) {
// add the file extension into the filename.
$filePathArr = explode('.', $filePath);
$fileExt = $filePathArr[count($filePathArr) - 1];
// append file ext into filename.
$jsFile->name = $jsFile->name . '.' . $fileExt;
$fileMime = $this->getFileMimeType($filePath);
$fileHash = md5($jsFile->name . $jsFile->filepath);
$esFile = FD::table('File');
$esFile->name = $jsFile->name;
$esFile->collection_id = $esCollectionId;
$esFile->hits = $jsFile->hits;
$esFile->hash = $fileHash;
$esFile->uid = $jsFile->esgroupid;
$esFile->type = SOCIAL_TYPE_GROUP;
$esFile->created = $jsFile->created;
$esFile->user_id = $jsFile->creator;
$esFile->size = $jsFile->filesize;
$esFile->mime = $fileMime;
$esFile->state = SOCIAL_STATE_PUBLISHED;
$esFile->storage = SOCIAL_STORAGE_JOOMLA;
$esFile->store();
// attach this file into discussion.
$esDiscussFile = FD::table('DiscussionFile');
$esDiscussFile->file_id = $esFile->id;
$esDiscussFile->discussion_id = $jsFile->esdiscussid;
$esDiscussFile->store();
// now we need to append the file tag into discussion content.
$fileTag = "\r\n";
$fileTag .= '[file id="' . $esFile->id . '"]' . $jsFile->name . '[/file]';
$esDiscuss = FD::table('Discussion');
$esDiscuss->load($jsFile->esdiscussid);
$esDiscuss->content = $esDiscuss->content . $fileTag;
$esDiscuss->store();
// now we copy the file into es.
$storage = $esFile->getStoragePath();
// Ensure that the storage path exists.
FD::makeFolder($storage);
$state = JFile::copy($filePath, $storage . '/' . $esFile->hash);
// now we add stream
$stream = FD::stream();
$tpl = $stream->getTemplate();
$group = FD::group($jsFile->esgroupid);
// this is a cluster stream and it should be viewable in both cluster and user page.
$tpl->setCluster($jsFile->esgroupid, SOCIAL_TYPE_GROUP, $group->type);
// Set the actor
$tpl->setActor($jsFile->creator, SOCIAL_TYPE_USER);
// Set the context
$tpl->setContext($esFile->id, SOCIAL_TYPE_FILES);
// Set the verb
$tpl->setVerb('uploaded');
// set date
$tpl->setDate($jsFile->created);
// Set the params to cache the group data
$registry = FD::registry();
$registry->set('group', $group);
$registry->set('file', $esFile);
// Set the params to cache the group data
$tpl->setParams($registry);
// since this is a cluster and user stream, we need to call setPublicStream
// so that this stream will display in unity page as well
// This stream should be visible to the public
$tpl->setAccess('core.view');
$stream->add($tpl);
$this->log('groupdiscussionsfile', $jsFile->id, $esFile->id);
$this->info->setInfo('File with id ' . $jsFile->id . ' for group discussion ' . $jsFile->discussionid . ' successfully migrated into EasySocial.');
} else {
$this->log('groupdiscussionsfile', $jsFile->id, 0);
$this->info->setInfo('File with id ' . $jsFile->id . ' for group discussion ' . $jsFile->discussionid . ' not found. Migration of this file aborted.');
}
}
return $this->info;
}
/**
* Override parent's behavior of deleting as we also need to delete physical files.
*
* @since 1.0
* @access public
* @param string
* @return bool
*/
public function delete($pk = null)
{
$state = parent::delete();
if (!$state) {
return false;
}
// Get config
$config = FD::config();
// Get the default avatars storage location.
$avatarsPath = JPATH_ROOT . '/' . FD::cleanPath($config->get('avatars.storage.container'));
// Test if the avatars path folder exists. If it doesn't we need to create it.
if (!FD::makeFolder($avatarsPath)) {
FD::logError(__FILE__, __LINE__, 'AVATARS: Unable to create the path ' . $avatarsPath);
$this->setError(JText::_('Errors when creating default container for avatar'));
return false;
}
// Get the default avatars storage location for this type.
$typePath = $config->get('avatars.storage.' . $this->type);
$storagePath = $avatarsPath . '/' . FD::cleanPath($typePath);
// Set the absolute path based on the uid.
$storagePath = $storagePath . '/' . $this->uid;
$this->deleteFolder($storagePath);
return $state;
}
/**
* Gets the storage path for photos folder
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function getStoragePath($uid, $type, $createFolders = true)
{
// Construct destination path
$config = FD::config();
// Get initial storage path
$storage = JPATH_ROOT;
// Append it with the container path
$storage = $storage . '/' . FD::cleanPath($config->get('avatars.storage.container'));
// Ensure that the folder exists
if ($createFolders) {
FD::makeFolder($storage);
}
// Append it with the type
$storage = $storage . '/' . FD::cleanPath($config->get('avatars.storage.' . $type));
// Ensure that the folder exists
if ($createFolders) {
FD::makeFolder($storage);
}
// Construct the last segment which contains the uid.
$storage = $storage . '/' . $uid;
// Ensure that the path exists.
if ($createFolders) {
FD::makeFolder($storage);
}
return $storage;
}
/**
* Allows caller to upload files
*
* @since 1.2
* @access public
* @param string
* @return
*/
public function addFile($title = null)
{
if (!$this->hasWriteAccess()) {
return FD::exception(JText::_('COM_EASYSOCIAL_EXPLORER_NO_ACCESS_TO_UPLOAD'));
}
// Ensure that the storage path really exists on the site
FD::makeFolder($this->storagePath);
// Get the maximum size allowed from the child
$max = $this->getMaxSize();
// Define uploader options
$options = array('name' => 'file', 'maxsize' => $max);
// Get uploaded file from $_FILE
$file = FD::uploader($options)->getFile();
// If there was an error getting uploaded file, stop.
if ($file instanceof SocialException) {
return $file;
}
// Get filename
$name = $file['name'];
// Get the folder to store this item to.
$collectionId = JRequest::getInt('id', 0);
$table = FD::table('File');
$table->name = $name;
$table->collection_id = $collectionId;
$table->hits = 0;
$table->hash = md5('tmp');
$table->uid = $this->uid;
$table->type = $this->type;
$table->created = JFactory::getDate()->toSql();
$table->user_id = FD::user()->id;
$table->size = filesize($file['tmp_name']);
$table->mime = $file['type'];
$table->state = SOCIAL_STATE_PUBLISHED;
$table->storage = SOCIAL_STORAGE_JOOMLA;
// Try to store the data on the database.
$table->store();
// Now we need to really upload the file.
$state = $table->storeWithFile($file);
// Format the data now
$result = $this->format(array($table));
return $result[0];
}
/**
* Identical to the store method but it also stores the file properties.
* Maps a file object into the correct properties.
*
* @since 1.0
* @access public
* @param $_FILES $file File data
*
* @return boolean True if success, false otherwise.
*/
public function storeWithFile($file)
{
// Check if file exists on the server
if (!isset($file['tmp_name']) || empty($file)) {
$this->setError(JText::_('COM_EASYSOCIAL_UPLOADER_FILE_NOT_FOUND'));
return false;
}
// Get the name of the uploaded file.
if (isset($file['name']) && !empty($file['name'])) {
$this->name = $file['name'];
}
// Get the mime type of the file.
if (isset($file['type']) && !empty($file['type'])) {
$this->mime = $file['type'];
}
// Get the file size.
if (isset($file['size']) && !empty($file['size'])) {
$this->size = $file['size'];
}
// If there's no type or the unique id is invalid we should break here.
if (!$this->type || !$this->uid) {
$this->setError(JText::_('COM_EASYSOCIAL_UPLOADER_COMPOSITE_ITEMS_NOT_DEFINED'));
return false;
}
// Generate a random hash for the file.
$this->hash = md5($this->name . $file['tmp_name']);
// Try to store the item first.
$state = $this->store();
// Once the script reaches here, we assume everything is good now.
// Copy the files over.
jimport('joomla.filesystem.file');
$storage = $this->getStoragePath();
// Ensure that the storage path exists.
FD::makeFolder($storage);
$state = JFile::copy($file['tmp_name'], $storage . '/' . $this->hash);
if (!$state) {
$this->setError(JText::sprintf('COM_EASYSOCIAL_UPLOADER_UNABLE_TO_COPY_TO_DESTINATION_FOLDER', $typePath . '/' . $this->uid . '/' . $this->hash));
return false;
}
return $state;
}
public function saveCover(&$post, $uid, $type)
{
$coverData = !empty($post[$this->inputName]) ? $post[$this->inputName] : '';
unset($post[$this->inputName]);
if (empty($coverData)) {
return true;
}
$coverData = FD::makeObject($coverData);
// Get the cover table.
$cover = FD::table('Cover');
// Try to load existing cover
$state = $cover->load(array('uid' => $uid, 'type' => $type));
// If no existing cover, then we set the uid and type.
if (!$state) {
$cover->uid = $uid;
$cover->type = $type;
}
// If both data does not exist, then we don't proceed to store the data.
if (empty($coverData->data) && empty($coverData->position)) {
return true;
}
if (!empty($coverData->data)) {
if ($coverData->data === 'delete') {
$cover->delete();
return true;
}
$coverObj = FD::makeObject($coverData->data);
// Get the cover album.
$album = SocialFieldsUserCoverHelper::getDefaultAlbum($uid, $type);
// Create the photo object.
$photo = SocialFieldsUserCoverHelper::createPhotoObject($uid, $type, $album->id, $coverObj->stock->title, false);
// If there are no cover set for this album, set it as cover.
if (empty($album->cover_id)) {
$album->cover_id = $photo->id;
$album->store();
}
// Construct the path to where the photo is temporarily uploaded.
// $tmpPath = SocialFieldsUserCoverHelper::getPath($this->inputName);
$tmpPath = dirname($coverObj->stock->path);
// Get the supposed path of where the cover should be
// Instead of doing SocialPhotos::getStoragePath, I copied the logic from there but only to create the folders up until albumId section.
// We do not want JPATH_ROOT to be included in the $storage variable
$storage = '/' . FD::cleanPath(FD::config()->get('photos.storage.container'));
FD::makeFolder(JPATH_ROOT . $storage);
$storage .= '/' . $album->id;
FD::makeFolder(JPATH_ROOT . $storage);
$storage .= '/' . $photo->id;
FD::makeFolder(JPATH_ROOT . $storage);
// Copy the photo from the temporary path to the storage folder.
$state = JFolder::copy($tmpPath, JPATH_ROOT . $storage, '', true);
// If cannot copy out the photo, then don't proceed
if ($state !== true) {
$this->setError(JText::_('PLG_FIELDS_COVER_ERROR_UNABLE_TO_MOVE_FILE'));
return false;
}
// Create the photo meta for each available sizes.
foreach ($coverObj as $key => $value) {
SocialFieldsUserCoverHelper::createPhotoMeta($photo, $key, $storage . '/' . $value->file);
}
// Set the uploaded photo as cover for this user.
$cover->setPhotoAsCover($photo->id);
}
// Set the position of the cover if available.
if (!empty($coverData->position)) {
$position = FD::makeObject($coverData->position);
if (isset($position->x)) {
$cover->x = $position->x;
}
if (isset($position->y)) {
$cover->y = $position->y;
}
}
// Store the cover object
$cover->store();
// And we're done.
return true;
}
/**
* Retrieves the storage path for this album
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function getStoragePath(SocialTableAlbum $album, $relative = false)
{
// Rename temporary folder to the destination.
jimport('joomla.filesystem.folder');
// Get destination folder path.
$storage = $album->getStoragePath($relative);
// Build the storage path now with the album id
$storage = $storage . '/' . $this->id;
// Ensure that the final storage path exists.
if (!$relative) {
FD::makeFolder($storage);
}
return $storage;
}
public function installPackage($file, $type, $allowedExtension = array(), $extract = true)
{
FD::checkToken();
$view = $this->getCurrentView();
if (empty($file['tmp_name'])) {
$view->setMessage(JText::_('COM_EASYSOCIAL_INSTALL_UPLOAD_ERROR_INVALID_TYPE'), SOCIAL_MSG_ERROR);
return false;
}
if ($file['type'] !== 'application/octet-stream') {
$view->setMessage(JText::_('COM_EASYSOCIAL_INSTALL_UPLOAD_ERROR_INVALID_TYPE'), SOCIAL_MSG_ERROR);
return false;
}
$fileext = pathinfo($file['name'], PATHINFO_EXTENSION);
if (empty($allowedExtension)) {
$allowedExtension = array($type);
}
if (!in_array($fileext, $allowedExtension)) {
$view->setMessage(JText::_('COM_EASYSOCIAL_INSTALL_UPLOAD_ERROR_INVALID_TYPE'), SOCIAL_MSG_ERROR);
return false;
}
$files = array();
if (in_array($fileext, $allowedExtension) && ($fileext !== 'zip' || !$extract)) {
$files[] = $file['tmp_name'];
}
$tmpPath = null;
if ($fileext === 'zip' && $extract) {
jimport('joomla.filesystem.archive');
$key = md5(uniqid() . $file['tmp_name']);
$tmpPath = SOCIAL_TMP . '/' . $key;
$state = FD::makeFolder($tmpPath);
if (!$state) {
$view->setMessage(JText::_('COM_EASYSOCIAL_INSTALL_UPLOAD_ERROR_UNABLE_TO_CREATE_TMP_FOLDER') . ': ' . $tmpPath, SOCIAL_MSG_ERROR);
return false;
}
$state = JArchive::extract($file['tmp_name'], $tmpPath);
if (!$state) {
$view->setMessage(JText::_('COM_EASYSOCIAL_INSTALL_UPLOAD_ERROR_UNABLE_TO_EXTRACT_PACKAGE'), SOCIAL_MSG_ERROR);
return false;
}
$scanExtension = array_diff($allowedExtension, array('zip'));
foreach ($scanExtension as $e) {
$files = array_merge($files, JFolder::files($tmpPath, '.' . $e . '$', true, true));
}
}
$model = FD::model($type);
foreach ($files as $file) {
if (!$model->install($file)) {
$view->setMessage($model->getError(), SOCIAL_MSG_ERROR);
return false;
}
}
if (!empty($tmpPath)) {
JFolder::delete($tmpPath);
}
$view->setMessage(JText::_('COM_EASYSOCIAL_INSTALL_UPLOAD_SUCCESSFULLY', SOCIAL_MSG_SUCCESS));
return true;
}
/**
* Gets the storage path for photos folder
*
* @since 1.0
* @access public
* @param string
* @return
*/
public static function getStoragePath($albumId, $photoId, $createFolders = true)
{
// Get destination folder path.
$config = FD::config();
$container = FD::cleanPath($config->get('photos.storage.container'));
$storage = JPATH_ROOT . '/' . $container;
// Test if the storage folder exists
if ($createFolders) {
FD::makeFolder($storage);
}
// Set the storage path to the album
$storage = $storage . '/' . $albumId;
// If it doesn't exist, create it.
if ($createFolders) {
FD::makeFolder($storage);
}
// Create a new folder for the photo
$storage = $storage . '/' . $photoId;
if ($createFolders) {
FD::makeFolder($storage);
}
// Re-generate the storage path since we do not want to store the JPATH_ROOT
$storage = '/' . $container . '/' . $albumId . '/' . $photoId;
return $storage;
}
/**
* Responsible to store the uploaded images.
*
* @since 1.0
* @access public
* @param null
*
* @author Mark Lee <*****@*****.**>
*/
public function upload($files)
{
// Get config object.
$config = FD::config();
// Do not proceed if image doesn't exist.
if (empty($files) || !isset($files['file'])) {
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_COVERS_FILE_UNAVAILABLE'));
return false;
}
// Get the single file input since the $files is an array.
$file = $files['file'];
// Get the default avatars storage location.
$coversPath = JPATH_ROOT . '/' . FD::cleanPath($config->get('covers.storage.container'));
// Test if the avatars path folder exists. If it doesn't we need to create it.
if (!FD::makeFolder($coversPath)) {
FD::logError(__FILE__, __LINE__, 'DEFAULT_COVERS: Unable to create the path ' . $coversPath);
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_COVERS_UNABLE_TO_CREATE_CONTAINER_FOLDER'));
return false;
}
// Get the defaults avatar path.
$defaultsPath = $coversPath . '/' . FD::cleanPath($config->get('covers.storage.default'));
// Ensure that the defaults path exist
if (!FD::makeFolder($defaultsPath)) {
FD::logError(__FILE__, __LINE__, 'DEFAULT_COVERS: Unable to create the path ' . $defaultsPath);
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_COVERS_UNABLE_TO_CREATE_DEFAULT_FOLDER'));
return false;
}
// Get the default avatars storage location for this type.
$typePath = $config->get('covers.storage.defaults.' . $this->type);
$storagePath = $defaultsPath . '/' . FD::cleanPath($typePath);
// Ensure storage path exists.
if (!FD::makeFolder($storagePath)) {
FD::logError(__FILE__, __LINE__, 'DEFAULT_COVERS: Unable to create the path ' . $storagePath);
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_COVERS_UNABLE_TO_CREATE_DEFAULT_FOLDER'));
return false;
}
// Get the profile id and construct the final path.
$idPath = FD::cleanPath($this->uid);
$storagePath = $storagePath . '/' . $idPath;
// Ensure storage path exists.
if (!FD::makeFolder($storagePath)) {
FD::logError(__FILE__, __LINE__, 'DEFAULT_COVERS: Unable to create the path ' . $storagePath);
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_COVERS_UNABLE_TO_CREATE_DEFAULT_FOLDER'));
return false;
}
// Get the image library to perform some checks.
$image = FD::get('Image');
$image->load($file['tmp_name']);
// Test if the image is really a valid image.
if (!$image->isValid()) {
FD::logError(__FILE__, __LINE__, 'DEFAULT_COVERS: Image uploaded ' . $file['name'] . ' is invalid');
$this->setError(JText::_('COM_EASYSOCIAL_PROFILES_DEFAULT_AVATARS_FILE_NOT_IMAGE'));
return false;
}
// Process covers storage.
$cover = FD::get('Cover', $image);
// Try to create the covers.
$sizes = $cover->create($storagePath);
// Test if the server returned an error.
if ($sizes === false) {
FD::logError(__FILE__, __LINE__, 'DEFAULT_COVERS: Error creating covers at ' . $storagePath);
$this->setError(JText::_('Sorry, there was some errors when creating the covers.'));
return false;
}
// Assign the values back.
foreach ($sizes as $size => $url) {
$this->{$size} = $url;
}
return true;
}
/**
* Retrieves the storage path for this album
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function getStoragePath($relative = false)
{
// Rename temporary folder to the destination.
jimport('joomla.filesystem.folder');
// Get destination folder path.
$config = FD::config();
$path = '';
if (!$relative) {
$path = JPATH_ROOT;
}
$path = $path . '/' . FD::cleanPath($config->get('photos.storage.container'));
// Ensure that the storage folder exists.
if (!$relative) {
FD::makeFolder($path);
}
// Build the storage path now with the album id
$path = $path . '/' . $this->id;
// Ensure that the final storage path exists.
if (!$relative) {
FD::makeFolder($path);
}
return $path;
}
public static function getStoragePath($inputName)
{
$path = SocialFieldsUserCoverHelper::getPath($inputName);
// If the folder exists, delete them first.
if (JFolder::exists($path)) {
JFolder::delete($path);
}
// Create folder if necessary.
FD::makeFolder($path);
// Re-generate the storage path since we do not want to store the JPATH_ROOT
$path = str_replace(JPATH_ROOT, '', $path);
return $path;
}
