PHP FD::storage方法代码示例

 /**
  * Retrieves the uri for this image
  *
  * @since	1.3
  * @access	public
  * @param	string
  * @return	
  */
 public function getUrl()
 {
     $config = FD::config();
     // Get the container location
     $container = FD::cleanPath($config->get('links.cache.location'));
     // Relative path to the item
     $relativePath = $this->getRelativePath();
     // Default base url
     $url = rtrim(JURI::root(), '/') . $relativePath;
     // Get the storage type for cached images for links
     if ($this->storage != 'joomla') {
         $storage = FD::storage($this->storage);
         $url = $storage->getPermalink($relativePath);
     }
     return $url;
 }

 /**
  * Processes the saving of the settings.
  *
  * @since	1.0
  * @access	public
  * @param	null
  * @author	Mark Lee <mark@stackideas.com>
  */
 public function save()
 {
     // Check for request forgeries.
     FD::checkToken();
     // Since there are more than 1 tasks are linked here, get the appropriate task here.
     $task = $this->getTask();
     $method = $task;
     $page = JRequest::getVar('page', '');
     $view = FD::view('Settings');
     // Get the posted data.
     $post = JRequest::get('POST');
     // Only load the config that is already stored.
     // We don't want to store everything as we want to have hidden settings.
     $configTable = FD::table('Config');
     $config = FD::registry();
     if ($configTable->load('site')) {
         $config->load($configTable->value);
     }
     $token = FD::token();
     if (!$post) {
         $view->setMessage(JText::_('COM_EASYSOCIAL_INVALID_POST_DATA'), SOCIAL_MSG_ERROR);
         return $view->call($method, $page);
     }
     // Some post vars are unwanted / unecessary because of the hidden inputs.
     $ignored = array('task', 'option', 'controller', 'view', $token, 'page');
     $updatedUserIndexing = false;
     foreach ($post as $key => $value) {
         if (!in_array($key, $ignored)) {
             // Replace all _ with .
             $key = str_ireplace('_', '.', $key);
             // If the value is an array, and there's only 1 index,
             // the input might need to be checked if it needs to be in an array form.
             // E.g: some,values,here,should,be,an,array
             if (is_array($value) && count($value) == 1) {
                 $value = FD::makeArray($value[0], ',');
             }
             if ($key == 'users.indexer.name' || $key == 'users.indexer.email') {
                 $previousVal = $config->get($key);
                 if ($previousVal != $value) {
                     $updatedUserIndexing = true;
                 }
             }
             $config->set($key, $value);
         }
     }
     // Convert the config object to a json string.
     $jsonString = $config->toString();
     $configTable = FD::table('Config');
     if (!$configTable->load('site')) {
         $configTable->type = 'site';
     }
     $configTable->set('value', $jsonString);
     // Try to store the configuration.
     if (!$configTable->store()) {
         $view->setMessage($configTable->getError(), SOCIAL_MSG_ERROR);
         return $view->call($method, $page);
     }
     // Check if any of the configurations are stored as non local
     if (($config->get('storage.photos') == 'amazon' || $config->get('storage.conversations') == 'amazon') && $config->get('storage.amazon.bucket') == '') {
         // Initialize the storage
         $bucket = FD::storage('Amazon')->init();
         $config->set('storage.amazon.bucket', $bucket);
         $configTable->set('value', $config->toString());
         $configTable->store();
     }
     $message = $updatedUserIndexing ? JText::_('COM_EASYSOCIAL_SETTINGS_SAVED_SUCCESSFULLY_WITH_USER_INDEXING_UPDATED') : JText::_('COM_EASYSOCIAL_SETTINGS_SAVED_SUCCESSFULLY');
     $view->setMessage($message, SOCIAL_MSG_SUCCESS);
     return $view->call($method, $page);
 }

 /**
  * Synchronizes photos from local storage to remote storage.
  *
  * @since	1.2
  * @access	public
  * @param	string
  * @return
  */
 public function syncPhotos()
 {
     $storageType = $this->getStorageType();
     // If site is configured to storage in joomla, we don't need to do anything
     if ($storageType == 'joomla') {
         return JText::_('Current photos storage is set to local.');
     }
     // Load up the storage library
     $storage = FD::storage($storageType);
     // Get the number of files to process at a time
     $limit = $this->getUploadLimit();
     // Get a list of photos that failed during the transfer
     $exclusion = $this->getFailedObjects('photos');
     // Get a list of files to be synchronized over.
     $model = FD::model('Photos');
     $options = array('pagination' => $limit, 'storage' => SOCIAL_STORAGE_JOOMLA, 'ordering' => 'created', 'sort' => 'asc', 'exclusion' => $exclusion);
     // Get a list of photos to sync to amazon
     $photos = $model->getPhotos($options);
     $total = 0;
     if (!$photos) {
         return JText::_('No photos to upload to Amazon S3 right now.');
     }
     // Get list of allowed photos
     $allowed = array('thumbnail', 'large', 'square', 'featured', 'medium', 'original', 'stock');
     foreach ($photos as $photo) {
         // Load the album
         $album = FD::table('Album');
         $album->load($photo->album_id);
         // If the album no longer exists, skip this
         if (!$album->id) {
             continue;
         }
         // Get the base path for the album
         $basePath = $photo->getStoragePath($album);
         $states = array();
         // Now we need to get all the available files for this photo
         $metas = $model->getMeta($photo->id, SOCIAL_PHOTOS_META_PATH);
         // Go through each meta
         foreach ($metas as $meta) {
             // To prevent some faulty data, we need to manually reconstruct the path here.
             $absolutePath = $meta->value;
             $file = basename($absolutePath);
             $container = FD::cleanPath($this->config->get('photos.storage.container'));
             // Reconstruct the path to the source file
             $source = JPATH_ROOT . '/' . $container . '/' . $album->id . '/' . $photo->id . '/' . $file;
             // To prevent faulty data, manually reconstruct the path here.
             $dest = $container . '/' . $album->id . '/' . $photo->id . '/' . $file;
             $dest = ltrim($dest, '/');
             // We only want to upload certain files
             if (in_array($meta->property, $allowed)) {
                 // Upload the file to the remote storage now
                 $state = $storage->push($photo->title . $photo->getExtension(), $source, $dest);
                 // Delete the source file if successfull and configured to do so.
                 if ($state && $this->deleteable()) {
                     JFile::delete($source);
                 }
                 $states[] = $state;
             }
         }
         $success = !in_array(false, $states);
         // If there are no errors, we want to update the storage for the photo
         if ($success) {
             $photo->storage = $storageType;
             $state = $photo->store();
             // if photo storage successfully updated to amazon, we need to update the cached object in stream_item.
             // Find and update the object from stream_item.
             $stream = FD::table('StreamItem');
             $options = array('context_type' => SOCIAL_TYPE_PHOTO, 'context_id' => $photo->id);
             $exists = $stream->load($options);
             if ($exists) {
                 $stream->params = FD::json()->encode($photo);
                 $stream->store();
             }
             $total += 1;
         }
         // Add this to the storage logs
         $this->log($photo->id, 'photos', $success);
     }
     if ($total > 0) {
         return JText::sprintf('%1s photos uploaded to remote storage', $total);
     }
     return JText::sprintf('No photos to upload to remote storage');
 }

 /**
  * Cleanup a folder
  *
  * @since	1.0
  * @access	public
  * @param	string		The target location to store the avatars
  * @return
  */
 public function cleanup($avatarTable)
 {
     // Don't delete if the avatar is from gallery
     if (!empty($avatarTable->avatar_id)) {
         return true;
     }
     // Delete previous avatars.
     $paths = $avatarTable->getPaths(true);
     $storage = FD::storage($avatarTable->storage);
     $storage->delete($paths);
     return true;
 }

 /**
  * Ends the output and allow user to download the file
  *
  * @since	1.0
  * @access	public
  * @param	string
  * @return
  */
 public function download()
 {
     // Update the hit counter
     $this->hits += 1;
     $this->store();
     if ($this->storage != 'joomla') {
         $storage = FD::storage($this->storage);
         $path = $this->getStoragePath(true);
         $path = $path . '/' . $this->hash;
         return JFactory::getApplication()->redirect($storage->getPermalink($path));
     }
     $storage = $this->getStoragePath();
     $file = $storage . '/' . $this->hash;
     jimport('joomla.filesystem.file');
     // If the file no longer exists, throw a 404
     if (!JFile::exists($file)) {
         JError::raiseError(404);
     }
     // Get the real file name
     $fileName = $this->name;
     // Get the file size
     $fileSize = filesize($file);
     header('Content-Description: File Transfer');
     header('Content-Type: application/octet-stream');
     header('Content-Disposition: attachment; filename="' . $fileName . '"');
     header('Content-Transfer-Encoding: binary');
     header('Expires: 0');
     header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
     header('Pragma: public');
     header('Content-Length: ' . $fileSize);
     ob_clean();
     flush();
     readfile($file);
     exit;
 }

 /**
  * Retrieves the permalink to the image given the size
  *
  * @since   1.0
  * @access  public
  * @param   string
  * @return
  */
 public function getSource($type = 'thumbnail')
 {
     static $paths = array();
     $config = FD::config();
     // Load the paths for this photo
     $model = FD::model('Photos');
     $metas = $model->getMeta($this->id, SOCIAL_PHOTOS_META_PATH);
     $obj = new stdClass();
     $path = FD::cleanPath($config->get('photos.storage.container'));
     $allowed = array('thumbnail', 'large', 'original', 'square', 'featured', 'medium');
     foreach ($metas as $meta) {
         $relative = $path . '/' . $this->album_id . '/' . $this->id . '/' . basename($meta->value);
         if ($this->storage != SOCIAL_STORAGE_JOOMLA && in_array($meta->property, $allowed)) {
             $storage = FD::storage($this->storage);
             $url = $storage->getPermalink($relative);
         } else {
             $url = rtrim(JURI::root(), '/') . '/' . $relative;
         }
         $obj->{$meta->property} = $url;
     }
     $paths[$this->id] = $obj;
     if (!isset($paths[$this->id]->{$type})) {
         $paths[$this->id]->{$type} = false;
     }
     return $paths[$this->id]->{$type};
 }

 /**
  * Retrieves the user's avatar location
  *
  * @access	public
  * @param   string	$size 	The avatar size to retrieve for.
  * @return  string  The current user's username.
  *
  * @author	Mark Lee <mark@stackideas.com>
  */
 public function getAvatar($size = SOCIAL_AVATAR_MEDIUM)
 {
     $config = FD::config();
     // If avatar id is being set, we need to get the avatar source
     if ($this->defaultAvatar) {
         $default = $this->defaultAvatar->getSource($size);
         return $default;
     }
     // If the avatar size that is being requested is invalid, return default avatar.
     $default = $this->getDefaultAvatar($size);
     if (!$this->avatars[$size] || empty($this->avatars[$size])) {
         return $default;
     }
     // Get the path to the avatar storage.
     $avatarLocation = FD::cleanPath($config->get('avatars.storage.container'));
     $usersAvatarLocation = FD::cleanPath($config->get('avatars.storage.user'));
     // Build the path now.
     $path = $avatarLocation . '/' . $usersAvatarLocation . '/' . $this->id . '/' . $this->avatars[$size];
     if ($this->avatarStorage == SOCIAL_STORAGE_JOOMLA) {
         // Build final storage path.
         $absolutePath = JPATH_ROOT . '/' . $path;
         // Detect if this file really exists.
         if (!JFile::exists($absolutePath)) {
             return $default;
         }
         $uri = rtrim(JURI::root(), '/') . '/' . $path;
     } else {
         $storage = FD::storage($this->avatarStorage);
         $uri = $storage->getPermalink($path);
     }
     return $uri;
 }

 /**
  * Synchronizes avatars from the site over to remote storage
  *
  * @since	1.2
  * @access	public
  * @param	string
  * @return
  */
 public function syncAvatars()
 {
     $config = FD::config();
     $type = $config->get('storage.photos', 'joomla');
     if ($type == 'joomla') {
         return JText::_('Current avatar storage is set to local.');
     }
     $storage = FD::storage($type);
     // Get the number of files to process at a time
     $limit = $config->get('storage.' . $type . '.limit', 20);
     // Get a list of excluded avatars that previously failed.
     $exclusion = $this->getFailedObjects('avatars');
     // Get a list of avatars to be synchronized over.
     $model = FD::model('Avatars');
     $options = array('limit' => $limit, 'storage' => SOCIAL_STORAGE_JOOMLA, 'uploaded' => true, 'ordering' => 'random', 'exclusion' => $exclusion);
     $avatars = $model->getAvatars($options);
     $total = 0;
     if (!$avatars) {
         return JText::_('No avatars to upload to Amazon S3 right now.');
     }
     foreach ($avatars as $avatar) {
         $small = $avatar->getPath(SOCIAL_AVATAR_SMALL, false);
         $medium = $avatar->getPath(SOCIAL_AVATAR_MEDIUM, false);
         $large = $avatar->getPath(SOCIAL_AVATAR_LARGE, false);
         $square = $avatar->getPath(SOCIAL_AVATAR_SQUARE, false);
         $smallPath = JPATH_ROOT . '/' . $small;
         $mediumPath = JPATH_ROOT . '/' . $medium;
         $largePath = JPATH_ROOT . '/' . $large;
         $squarePath = JPATH_ROOT . '/' . $square;
         $success = false;
         if ($storage->push($avatar->id, $smallPath, $small) && $storage->push($avatar->id, $mediumPath, $medium) && $storage->push($avatar->id, $largePath, $large) && $storage->push($avatar->id, $squarePath, $square)) {
             $avatar->storage = $type;
             // Delete all the files now
             JFile::delete($smallPath);
             JFile::delete($mediumPath);
             JFile::delete($largePath);
             JFile::delete($squarePath);
             $avatar->store();
             $success = true;
         }
         // Add this to the storage logs
         $log = FD::table('StorageLog');
         $log->object_id = $avatar->id;
         $log->object_type = 'avatars';
         $log->target = $type;
         $log->state = $success;
         $log->created = FD::date()->toSql();
         $log->store();
         $total += 1;
     }
     if ($total > 0) {
         return JText::sprintf('%1s avatars uploaded to remote storage', $total);
     }
 }

 /**
  * Retrieves the user's avatar location
  *
  * @author  Mark Lee <mark@stackideas.com>
  * @since   1.2
  * @access  public
  * @param   string  $size   The avatar size to retrieve for.
  * @return  string          The avatar uri.
  */
 public function getAvatar($size = SOCIAL_AVATAR_MEDIUM)
 {
     $config = FD::config();
     // If the avatar size that is being requested is invalid, return default avatar.
     $default = $this->getDefaultAvatar($size);
     if (!$this->avatars[$size] || empty($this->avatars[$size])) {
         // Check if parent exist and call the parent.
         if ($this->hasParent()) {
             return $this->getParent()->getAvatar($size);
         }
         return $default;
     }
     // Get the path to the avatar storage.
     $container = FD::cleanPath($config->get('avatars.storage.container'));
     $location = FD::cleanPath($config->get('avatars.storage.' . $this->cluster_type));
     // Build the path now.
     $path = $container . '/' . $location . '/' . $this->id . '/' . $this->avatars[$size];
     if ($this->avatarStorage == SOCIAL_STORAGE_JOOMLA) {
         // Build final storage path.
         $absolutePath = JPATH_ROOT . '/' . $path;
         // Detect if this file really exists.
         if (!JFile::exists($absolutePath)) {
             return $default;
         }
         $uri = rtrim(JURI::root(), '/') . '/' . $path;
     } else {
         $storage = FD::storage($this->avatarStorage);
         $uri = $storage->getPermalink($path);
     }
     return $uri;
 }