PHP FD::photo方法代码示例

 /**
  * Displays the dialog to allow user to crop avatar
  *
  * @since	1.2
  * @access	public
  * @param	string
  * @return
  */
 public function crop()
 {
     // Require the user to be logged in
     FD::requireLogin();
     // Load up the ajax library
     $ajax = FD::ajax();
     // Get the unique object.
     $uid = JRequest::getInt('uid');
     $type = JRequest::getCmd('type');
     // Get photo id
     $id = JRequest::getInt('id');
     $table = FD::table('Photo');
     $table->load($id);
     $redirectUrl = JRequest::getVar('redirectUrl', '');
     // Load up the library
     $lib = FD::photo($table->uid, $table->type, $table);
     if (!$table->id) {
         return $this->deleted($lib);
     }
     // Check if the user is really allowed to upload avatar
     if (!$lib->canUseAvatar()) {
         return $ajax->reject();
     }
     $redirect = JRequest::getInt('redirect', 1);
     $theme = FD::themes();
     $theme->set('uid', $uid);
     $theme->set('type', $type);
     $theme->set('redirectUrl', $redirectUrl);
     $theme->set('photo', $lib->data);
     $theme->set('redirect', $redirect);
     $output = $theme->output('site/avatar/crop');
     return $ajax->resolve($output);
 }

 public function delete_photo()
 {
     $user = JFactory::getUser($this->plugin->get('user')->id);
     $app = JFactory::getApplication();
     $id = $app->input->get('id', 0, 'INT');
     // Load the photo table
     $photo = FD::table('Photo');
     $photo->load($id);
     $lib = FD::photo($photo->uid, $photo->type, $photo);
     if (!$id && !$photo->id) {
         return false;
     }
     // Load the photo library
     // Test if the user is allowed to delete the photo
     if (!$lib->deleteable()) {
         return false;
     }
     // Try to delete the photo
     $state = $photo->delete();
     if (!$state) {
         return false;
     } else {
         return $state;
     }
 }

 public function photosSchema($rows, $userid)
 {
     $lang = JFactory::getLanguage();
     $lang->load('com_easysocial', JPATH_ADMINISTRATOR, 'en-GB', true);
     $result = array();
     foreach ($rows as $ky => $row) {
         if (isset($row->id)) {
             $item = new PhotosSimpleSchema();
             $item->isowner = $row->uid == $userid ? true : false;
             $item->id = $row->id;
             $item->album_id = $row->album_id;
             $item->cover_id = $row->cover_id;
             $item->type = $row->type;
             $item->uid = $row->id;
             // for post comment photo id is required.
             $item->user_id = $row->user_id;
             $item->title = JText::_($row->title);
             $item->caption = JText::_($row->caption);
             $item->created = $row->created;
             $item->state = $row->state;
             $item->assigned_date = $row->assigned_date;
             $item->image_large = $row->image_large;
             $item->image_square = $row->image_square;
             $item->image_thumbnail = $row->image_thumbnail;
             $item->image_featured = $row->image_featured;
             $like = FD::photo();
             $like->data->id = $row->id;
             $data = $like->likes();
             $item->likes = $this->createlikeObj($data, $userid);
             $comobj = $like->comments();
             $comobj->stream_id = 1;
             $item->comment_element = $comobj->element . "." . $comobj->group . "." . $comobj->verb;
             $item->comments = $this->createCommentsObj($comobj);
             $result[] = $item;
         }
     }
     return $result;
 }

 /**
  * Displays the move to album dialog
  *
  * @since	1.2
  * @access	public
  * @param	string
  * @return
  */
 public function moveToAnotherAlbum()
 {
     $ajax = FD::ajax();
     // Get the current user.
     $my = FD::user();
     // Get photo
     $id = JRequest::getInt('id');
     $photo = FD::table('photo');
     $photo->load($id);
     // If photo id is invalid, reject this.
     if (!$photo->id || !$id) {
         return $ajax->reject();
     }
     // Load up the photo lib
     $lib = FD::photo($photo->uid, $photo->type, $photo);
     // Check if the user is really allowed to move the photo
     if (!$lib->canMovePhoto()) {
         return $ajax->reject();
     }
     // Get albums
     $model = FD::model('Albums');
     $albums = $model->getAlbums($my->id, SOCIAL_TYPE_USER, array('exclusion' => $photo->album_id, 'core' => false));
     // Get dialog
     $theme = FD::themes();
     $theme->set('albums', $albums);
     $theme->set('photo', $photo);
     $html = $theme->output('site/photos/dialog.move');
     return $ajax->resolve($html);
 }

 public function uploadPhoto($log_usr = 0, $type = null)
 {
     // Get current logged in user.
     $my = FD::user($log_usr);
     // Get user access
     $access = FD::access($my->id, SOCIAL_TYPE_USER);
     // Load up the photo library
     $lib = FD::photo($log_usr, $type);
     // Define uploader options
     $options = array('name' => 'file', 'maxsize' => $lib->getUploadFileSizeLimit());
     // Get uploaded file
     $file = FD::uploader($options)->getFile();
     // Load the iamge object
     $image = FD::image();
     $image->load($file['tmp_name'], $file['name']);
     // Detect if this is a really valid image file.
     if (!$image->isValid()) {
         return "invalid image";
     }
     // Load up the album's model.
     $albumsModel = FD::model('Albums');
     // Create the default album if necessary
     $album = $albumsModel->getDefaultAlbum($log_usr, $type, SOCIAL_ALBUM_STORY_ALBUM);
     // Bind photo data
     $photo = FD::table('Photo');
     $photo->uid = $log_usr;
     $photo->type = $type;
     $photo->user_id = $my->id;
     $photo->album_id = $album->id;
     $photo->title = $file['name'];
     $photo->caption = '';
     $photo->state = 1;
     $photo->ordering = 0;
     // Set the creation date alias
     $photo->assigned_date = FD::date()->toMySQL();
     // Trigger rules that should occur before a photo is stored
     $photo->beforeStore($file, $image);
     // Try to store the photo.
     $state = $photo->store();
     // Load the photos model
     $photosModel = FD::model('Photos');
     // Get the storage path for this photo
     $storage = FD::call('Photos', 'getStoragePath', array($album->id, $photo->id));
     // Get the photos library
     $photoLib = FD::get('Photos', $image);
     $paths = $photoLib->create($storage);
     // Create metadata about the photos
     if ($paths) {
         foreach ($paths as $type => $fileName) {
             $meta = FD::table('PhotoMeta');
             $meta->photo_id = $photo->id;
             $meta->group = SOCIAL_PHOTOS_META_PATH;
             $meta->property = $type;
             $meta->value = $storage . '/' . $fileName;
             $meta->store();
             // We need to store the photos dimension here
             list($width, $height, $imageType, $attr) = getimagesize(JPATH_ROOT . $storage . '/' . $fileName);
             // Set the photo dimensions
             $meta = FD::table('PhotoMeta');
             $meta->photo_id = $photo->id;
             $meta->group = SOCIAL_PHOTOS_META_WIDTH;
             $meta->property = $type;
             $meta->value = $width;
             $meta->store();
             $meta = FD::table('PhotoMeta');
             $meta->photo_id = $photo->id;
             $meta->group = SOCIAL_PHOTOS_META_HEIGHT;
             $meta->property = $type;
             $meta->value = $height;
             $meta->store();
         }
     }
     // After storing the photo, trigger rules that should occur after a photo is stored
     //$photo->afterStore( $file , $image );
     //$sphoto = new SocialPhotos($photo_obj->id);
     return $photo;
 }

 /**
  * Determines if the user is allowed to edit this photo
  *
  * @deprecated  1.2
  * @since   1.0
  * @access  public
  * @param   int     The user to check against (optional)
  * @return  bool    True if success, false otherwise
  */
 public function editable($id = null)
 {
     $lib = FD::photo($this->uid, $this->type, $this);
     // Why shareable instead of editable?
     // Changing to editable for now
     // return $lib->shareable();
     return $lib->editable();
 }

<div class="es-album-photos">

	<div class="es-photo-item-group no-transition" data-photo-item-group>

		<div class="es-media-item es-photo-item layout-item grid-sizer">
			<div><div></div></div>
		</div>

		<?php 
if (!empty($photos)) {
    ?>
			<?php 
    foreach ($photos as $photo) {
        ?>
				<?php 
        echo FD::photo($photo->uid, $photo->type, $photo)->renderItem($options['photoItem']);
        ?>
			<?php 
    }
    ?>
		<?php 
}
?>
	</div>

	<div class="no-photos-hint content-hint">
		<?php 
echo JText::_("COM_EASYSOCIAL_NO_PHOTOS_AVAILABLE");
?>
	</div>

 /**
  * Allows caller to create an avatar by posted the $_FILE data
  *
  * @since   1.0
  * @access  public
  * @param   string
  * @return
  */
 public function createAvatarFromFile()
 {
     // Check for request forgeries
     FD::checkToken();
     // Only registered users should be allowed to upload photos
     FD::requireLogin();
     // Get the current view
     $view = $this->getCurrentView();
     $config = FD::config();
     // Get the unique item id
     $uid = JRequest::getInt('uid');
     $type = JRequest::getCmd('type');
     // Get current user.
     $my = FD::user();
     if (!$uid && !$type) {
         $view->setMessage(JText::_('COM_EASYSOCIAL_PHOTOS_INVALID_ID_PROVIDED'), SOCIAL_MSG_ERROR);
         return $view->call('createAvatar');
     }
     // Load up the photo library
     $lib = FD::photo($uid, $type);
     // Set uploader options
     $options = array('name' => 'avatar_file', 'maxsize' => $lib->getUploadFileSizeLimit());
     // Get uploaded file
     $file = FD::uploader($options)->getFile();
     // If there was an error getting uploaded file, stop.
     if ($file instanceof SocialException) {
         $view->setMessage($file);
         return $view->call('createAvatar');
     }
     // Load the image
     $image = FD::image();
     $image->load($file['tmp_name'], $file['name']);
     // Check if there's a profile photos album that already exists.
     $albumModel = FD::model('Albums');
     // Retrieve the default album for this node.
     $album = $lib->getDefaultAlbum();
     $photo = FD::table('Photo');
     $photo->uid = $uid;
     $photo->type = $type;
     $photo->user_id = $my->id;
     $photo->album_id = $album->id;
     $photo->title = $file['name'];
     $photo->caption = '';
     $photo->ordering = 0;
     // Set the creation date alias
     $photo->assigned_date = FD::date()->toMySQL();
     // We need to set the photo state to "SOCIAL_PHOTOS_STATE_TMP"
     $photo->state = SOCIAL_PHOTOS_STATE_TMP;
     // Try to store the photo first
     $state = $photo->store();
     // Bind any exif data if there are any.
     // Only bind exif data for jpg files (if want to add tiff, then do add it here)
     if ($image->hasExifSupport()) {
         $photo->mapExif($file);
     }
     if (!$state) {
         $view->setMessage(JText::_('COM_EASYSOCIAL_PHOTOS_ERROR_CREATING_IMAGE_FILES'), SOCIAL_MSG_ERROR);
         return $view->call('createAvatar');
     }
     // Push all the ordering of the photo down
     $photosModel = FD::model('photos');
     $photosModel->pushPhotosOrdering($album->id, $photo->id);
     // Render photos library
     $photoLib = FD::get('Photos', $image);
     $storage = $photoLib->getStoragePath($album->id, $photo->id);
     $paths = $photoLib->create($storage);
     // Create metadata about the photos
     foreach ($paths as $type => $fileName) {
         $meta = FD::table('PhotoMeta');
         $meta->photo_id = $photo->id;
         $meta->group = SOCIAL_PHOTOS_META_PATH;
         $meta->property = $type;
         $meta->value = $storage . '/' . $fileName;
         $meta->store();
     }
     // Retrieve the original photo again.
     $image = $photo->getImageObject('original');
     return $view->call('createAvatar', $photo);
 }

 public function addPhotoAlbum($log_usr = 0, $album_id)
 {
     $my = FD::user();
     // Load up the configuration
     $config = FD::config();
     // Load the album table
     $album = FD::table('Album');
     $album->load($album_id);
     // Check if the album id provided is valid
     if (!$album->id || !$album->id) {
         return "album not valid";
     }
     // Get the uid and the type
     $uid = $album->uid;
     $type = $album->type;
     // Load the photo library
     $lib = FD::photo($uid, $type);
     // Set uploader options
     $options = array('name' => 'file', 'maxsize' => $lib->getUploadFileSizeLimit());
     // Get uploaded file
     $file = FD::uploader($options)->getFile();
     // If there was an error getting uploaded file, stop.
     if ($file instanceof SocialException) {
         return false;
     }
     // Load the image object
     $image = FD::image();
     $image->load($file['tmp_name'], $file['name']);
     // Detect if this is a really valid image file.
     if (!$image->isValid()) {
         return false;
     }
     // Bind the photo data now
     $photo = FD::table('Photo');
     $photo->uid = $uid;
     $photo->type = $type;
     $photo->user_id = $album->uid;
     $photo->album_id = $album->id;
     $photo->title = $file['name'];
     $photo->caption = '';
     $photo->ordering = 0;
     $photo->state = SOCIAL_STATE_PUBLISHED;
     // Set the creation date alias
     $photo->assigned_date = FD::date()->toMySQL();
     // Cleanup photo title.
     $photo->cleanupTitle();
     // Trigger rules that should occur before a photo is stored
     $photo->beforeStore($file, $image);
     // Try to store the photo.
     $state = $photo->store();
     if (!$state) {
         return false;
     }
     // If album doesn't have a cover, set the current photo as the cover.
     //~ if (!$album->hasCover()) {
     //~ $album->cover_id    = $photo->id;
     //~
     //~ // Store the album
     //~ $album->store();
     //~ }
     // Get the photos library
     $photoLib = FD::get('Photos', $image);
     // Get the storage path for this photo
     $storageContainer = FD::cleanPath($config->get('photos.storage.container'));
     $storage = $photoLib->getStoragePath($album->id, $photo->id);
     $paths = $photoLib->create($storage);
     // We need to calculate the total size used in each photo (including all the variants)
     $totalSize = 0;
     // Create metadata about the photos
     if ($paths) {
         foreach ($paths as $type => $fileName) {
             $meta = FD::table('PhotoMeta');
             $meta->photo_id = $photo->id;
             $meta->group = SOCIAL_PHOTOS_META_PATH;
             $meta->property = $type;
             // do not store the container path as this path might changed from time to time
             $tmpStorage = str_replace('/' . $storageContainer . '/', '/', $storage);
             $meta->value = $tmpStorage . '/' . $fileName;
             $meta->store();
             // We need to store the photos dimension here
             list($width, $height, $imageType, $attr) = getimagesize(JPATH_ROOT . $storage . '/' . $fileName);
             // Set the photo size
             $totalSize += filesize(JPATH_ROOT . $storage . '/' . $fileName);
             // Set the photo dimensions
             $meta = FD::table('PhotoMeta');
             $meta->photo_id = $photo->id;
             $meta->group = SOCIAL_PHOTOS_META_WIDTH;
             $meta->property = $type;
             $meta->value = $width;
             $meta->store();
             $meta = FD::table('PhotoMeta');
             $meta->photo_id = $photo->id;
             $meta->group = SOCIAL_PHOTOS_META_HEIGHT;
             $meta->property = $type;
             $meta->value = $height;
             $meta->store();
         }
     }
     // Set the total photo size
     $photo->total_size = $totalSize;
//.........这里部分代码省略.........

 /**
  * Allows use to download a photo from the site.
  *
  * @since	1.0
  * @access	public
  * @param	string
  * @return
  */
 public function download()
 {
     // Check if photos is enabled
     $this->checkFeature();
     // Load up info object
     $info = FD::info();
     // Get the id of the photo
     $id = JRequest::getInt('id');
     $photo = FD::table('Photo');
     $photo->load($id);
     // Id provided must be valid
     if (!$id || !$photo->id) {
         $this->setMessage(JText::_('COM_EASYSOCIAL_PHOTOS_INVALID_PHOTO_ID_PROVIDED'), SOCIAL_MSG_ERROR);
         $info->set($this->getMessage());
         return $this->redirect(FRoute::albums(array(), false));
     }
     // Load up photo library
     $lib = FD::photo($photo->uid, $photo->type, $photo);
     if (!$lib->downloadable()) {
         return $this->restricted($lib);
     }
     // Let's try to download the file now
     $photo->download();
 }

 /**
  * Allows caller to remove a photo
  *
  * @since	1.2
  * @access	public
  */
 public function remove()
 {
     // Check for request forgeries
     FD::checkToken();
     // Only logged in users allowed
     FD::requireLogin();
     // Get the current view
     $view = $this->getCurrentView();
     $uid = JRequest::getInt('uid');
     $type = JRequest::getCmd('type');
     if (!$uid && !$type) {
         $view->setMessage(JText::_('COM_EASYSOCIAL_PHOTOS_INVALID_ID_PROVIDED'), SOCIAL_MSG_ERROR);
         return $view->call(__FUNCTION__);
     }
     // Get the cover object
     $cover = FD::table('Cover');
     $state = $cover->load(array('uid' => $uid, 'type' => $type));
     if (!$state) {
         $view->setMessage(JText::_('COM_EASYSOCIAL_PHOTOS_INVALID_ID_PROVIDED'), SOCIAL_MSG_ERROR);
         return $view->call(__FUNCTION__);
     }
     // Load up the photo library
     $lib = FD::photo($uid, $type, $cover->photo_id);
     if (!$lib->canDeleteCover()) {
         $view->setMessage(JText::_('COM_EASYSOCIAL_PHOTOS_NO_PERMISSION_TO_DELETE_COVER'), SOCIAL_MSG_ERROR);
         return $view->call(__FUNCTION__);
     }
     // Delete the cover.
     $cover->delete();
     return $view->call(__FUNCTION__);
 }

 /**
  * Method to allow caller to load more photos in an album.
  *
  * @since	1.2.11
  * @access	public
  * @param	string
  * @return
  */
 public function loadMore($photos = array(), $nextStart = 0)
 {
     $ajax = FD::ajax();
     if ($this->hasErrors()) {
         return $ajax->reject($this->getMessage());
     }
     // Get the current logged in user.
     $my = FD::user();
     // Get layout
     $layout = JRequest::getCmd('layout', 'item');
     $options = array('viewer' => $my->id, 'layout' => $layout, 'showResponse' => false, 'showTags' => false);
     if ($layout == "dialog") {
         $options['showForm'] = false;
         $options['showInfo'] = false;
         $options['showStats'] = false;
         $options['showToolbar'] = false;
     }
     $htmls = array();
     foreach ($photos as $photo) {
         $lib = FD::photo($photo->uid, $photo->type, $photo);
         $htmls[] = $lib->renderItem($options);
     }
     return $ajax->resolve($htmls, $nextStart);
 }

 /**
  * Post process after the photo is uploaded on the site
  *
  * @since	1.0
  * @access	public
  * @param	string
  * @return
  */
 public function upload($photo = null, $paths = array())
 {
     $json = FD::json();
     // If there was an error uploading the photo, throw proper error message
     if ($this->hasErrors()) {
         $json->send($this->getMessage());
     }
     // Get the current logged in user
     $my = FD::user();
     // Get the layout to display
     $layout = JRequest::getCmd('layout', 'item');
     $options = array('viewer' => $my->id, 'layout' => $layout, 'showResponse' => false, 'showTags' => false);
     // Load up the photo library
     $lib = FD::photo($photo->uid, $photo->type, $photo);
     $output = $lib->renderItem($options);
     $response = new stdClass();
     $response->data = $photo->export();
     $response->html = $output;
     $json->send($response);
 }