<?php /** * SimpleVimeo * * API Framework for vimeo.com * @package SimpleVimeo * @author Adrian Rudnik <adrian@periocode.de> * @link http://code.google.com/p/php5-simplevimeo/ */ /** * Enable debug to output raw request and response information */ define('VIMEO_DEBUG_REQUEST', true); define('VIMEO_DEBUG_RESPONSE', true); /** * Vimeo base class * * Provides vital functions to API (access, permission and object handling) * * @package SimpleVimeo * @subpackage Base */ class VimeoBase { const PROJECT_NAME = 'php5-simplevimeo'; /** * Currently logged in user object * @var VimeoUserEntity */ private static $oUser = false; /** * Currently logged in user permission * @var string */ private static $ePermission = false; /** * Currently logged in user token * @var string */ private static $sToken = false; /** * Vimeo Application API key * @var string */ private static $sApiKey = '7a223534b3c1d0979a954f93cb746173 '; /** * Vimeo Application API secret key * @var string */ private static $sApiSecret = 'b11e83370'; const VIMEO_REST_URL = 'http://vimeo.com/api/rest/'; const VIMEO_AUTH_URL = 'http://vimeo.com/services/auth/'; const VIMEO_UPLOAD_URL = 'http://vimeo.com/services/upload/'; const VIMEO_LOGIN_URL = 'http://vimeo.com/log_in'; /** * You can choose between the following engines: * executeRemoteCall_FSOCK = PHP5 file_get_content and stream_contexts (bad error handling) * executeRemoteCall_CURL = CURL is used for file transfer (better error handling) */ const REQUEST_ENGINE_CURL = 'executeRemoteCall_CURL'; const VIDEOPOST_ENGINE_FSOCK = 'executeVideopostCall_CURL'; const PERMISSION_NONE = false; const PERMISSION_READ = 'read'; const PERMISSION_WRITE = 'write'; const PERMISSION_DELETE = 'delete'; const COOKIE_FILE = '/tmp/simplevimeo.cookies'; const DEBUG_ENABLE = false; const DEBUG_LOGFILE = '/tmp/simplevimeo.debug'; /** * Debug output function */ public static function debug($sTitle, $sContent) { if(self::DEBUG_ENABLE) { $sMessage = 'DEBUG ' . date('Y-m-d H:i:s', time()) . "\n"; $sMessage .= 'CONTENT: ' . $sContent . "\n"; $sMesasge .= $sContent . "\n\n"; $fhLog = fopen(self::DEBUG_LOGFILE, 'a+'); if(!$fhLog) { throw new VimeoBaseException('Debug Logfile "' . self::DEBUG_LOGFILE . '" could not be found or written'); } else { fputs($fhLog, $sMessage); fclose($fhLog); } } } /** * Update Authentication * * Initializes user and permission information if a token is present. * You can alter this method or skip it if you store user information * and permission in an external database. Then i would recommend a * VimeoAuthRequest::checkLoogin for confirmation. * * @access private * @return void */ private function updateAuthentication() { if(self::$sToken && (!self::$ePermission || !self::$oUser)) { $oResponse = VimeoAuthRequest::checkToken(self::$sToken); // Parse user self::$oUser = $oResponse->getUser(); // Parse permission self::$ePermission = $oResponse->getPermission(); } } /** * Check permission * * Checks the current user permission with the given one. This will be * heavily used by the executeRemoteCall method to ensure the user * will not run into trouble. * * @access public * @param string Needed Permission * @return boolean TRUE if access can be granted, FALSE if permission denied */ public function checkPermission($ePermissionNeeded) { // Update authentication data before permission check self::updateAuthentication(); // Permission DELETE check if($ePermissionNeeded == self::PERMISSION_DELETE && self::$ePermission == self::PERMISSION_DELETE) { return true; } // Permission WRITE check if($ePermissionNeeded == self::PERMISSION_WRITE && (self::$ePermission == self::PERMISSION_DELETE || self::$ePermission == self::PERMISSION_WRITE)) { return true; } // Permission READ check if($ePermissionNeeded == self::PERMISSION_READ && (self::$ePermission == self::PERMISSION_DELETE || self::$ePermission == self::PERMISSION_WRITE || self::$ePermission == self::PERMISSION_READ)) { return true; } return false; } /** * Proxy for API queries * * Will check permission for the requested API method as well as type * of the object result response or exception. Will call the given * API query handler method (default: executeRemoteCall_CURL) for * the raw connection stuff * * @access public * @param string API method name * @param array Additional arguments that need to be passed to the API * @return VimeoResponse Response object of API corresponding query (for vimeo.test.login you will get VimeoTestLoginResponse object) */ public function executeRemoteCall($sMethod, $aArgs = array()) { // Get exception handler $sExceptionClass = VimeoMethod::getExceptionObjectForMethod($sMethod); // Check for errors in parameters $sTargetClass = VimeoMethod::getTargetObjectForMethod($sMethod); // Get the permission needed to run this method $ePermissionNeeded = VimeoMethod::getPermissionRequirementForMethod($sMethod); // If permission requirement is not met refuse to even call the API, safes bandwith for both ends if($ePermissionNeeded != VimeoBase::PERMISSION_NONE && !self::checkPermission($ePermissionNeeded)) { throw new $sExceptionClass('Permission error: "' . VimeoMethod::getPermissionRequirementForMethod($sMethod) . '" needed, "' . self::$ePermission . '" given'); } // Append method to request arguments $aArgs['method'] = $sMethod; // Check that the API query handler method exists and can be called if(!method_exists(__CLASS__, self::REQUEST_ENGINE_CURL)) { throw new VimeoBaseException('Internal error: Request engine handler method not found', 2); } // Build up the needed API arguments // Set API key $aArgs['api_key'] = self::$sApiKey; // Set request format $aArgs['format'] = 'php'; // Set token if(self::$sToken) $aArgs['auth_token'] = self::$sToken; // Generate signature $aArgs['api_sig'] = self::buildSignature($aArgs); // Do the request $aResponse = call_user_func(array(__CLASS__, self::REQUEST_ENGINE_CURL), $aArgs); // Debug request if(defined('VIMEO_DEBUG_REQUEST') && VIMEO_DEBUG_REQUEST) { self::debug('API request', print_r($aArgs, true)); } // Debug response if(defined('VIMEO_DEBUG_RESPONSE') && VIMEO_DEBUG_RESPONSE) { self::debug('API response', print_r($aResponse, true)); } // Transform the result into a result class $oResult = new $sTargetClass($aResponse); // Check if request was successfull if(!$oResult->getStatus()) { // If not, create an given exception class for the given method and pass through error code and message throw new $sExceptionClass($oResult->getError()->getMessage(), $oResult->getError()->getCode()); } // Return the base class object instance for the corresponding API query return $oResult; } /** * Execute raw API query with CURL * * Implements CURL API queries in php format response * * @author Ted Roden * @access private * @param array Additional arguments for the API query * @return stdClass Simple PHP object enclosing the API result */ private function executeRemoteCall_CURL($aArgs) { $ch = curl_init(self::VIMEO_REST_URL); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs); curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME); $data = curl_exec($ch); if(curl_errno($ch)) throw new VimeoRequestException('executeRemoteCall_CURL error: ' . curl_error($ch), curl_errno($ch)); else { curl_close($ch); if(!$data || strlen(trim($data)) < 2) { throw new VimeoRequestException('API request error: No result returned.', 1); } return unserialize($data); } } /** * Execute raw API query with FSOCK * * Implements FSOCK API queries in php format response * * @access private * @param array Additional arguemnts for the API query * @return stdClass Simple PHP object enclosing the API result */ private function executeRemoteCall_FSOCK($aArgs) { $sResponse = file_get_contents(self::VIMEO_REST_URL, NULL, stream_context_create(array('http' => array('method' => 'POST', 'header'=> 'Content-type: application/x-www-form-urlencoded', 'content' => http_build_query($aArgs))))); if(!$sResponse || strlen(trim($sResponse)) < 2) { throw new VimeoRequestException('API request error: No result returned.', 1); } else { return unserialize($sResponse); } } /** * Proxy for video uploads * * Will call the given video upload handler method (default: executeVideopostCall_FSOCK) * for the raw connection and send stuff * * @access public * @param string Local filename to be transfered * @param string Ticket * @return string VimeoVideosCheckUploadStatusResponse */ public function executeVideopostCall($sFilename, $sTicket = false) { // Check that the upload query handler method exists and can be called if(!method_exists(__CLASS__, self::VIDEOPOST_ENGINE_FSOCK)) { throw new VimeoUploadException('Upload error: Videopost engine handler method not found', 1); } // If permission requirement is not met refuse to even call the API, safes bandwith for both ends if(!self::checkPermission(VimeoBase::PERMISSION_WRITE)) { throw new VimeoUploadException('Upload error: Missing "write" permission for current user', 2); } // Check that the file exists if(!file_exists($sFilename)) { throw new VimeoUploadException('Upload error: Local file does not exists', 3); } // Check that the file is readable if(!is_readable($sFilename)) { throw new VimeoUploadException('Upload error: Local file is not readable', 4); } // Check that the file size is not larger then the allowed size you can upload $oResponse = VimeoPeopleRequest::getUploadStatus(); if(filesize($sFilename) > $oResponse->getRemainingBytes()) { throw new VimeoUploadException('Upload error: Videosize exceeds remaining bytes', 5); } // Try to get a upload ticket if(!$sTicket) { $oResponse = VimeoVideosRequest::getUploadTicket(); $sTicket = $oResponse->getTicket(); } // Build up the needed API arguments // Set API key $aArgs['api_key'] = self::$sApiKey; // Set request format $aArgs['format'] = 'php'; // Set token if(self::$sToken) $aArgs['auth_token'] = self::$sToken; // Set ticket $aArgs['ticket_id'] = $sTicket; // Generate signature $aArgs['api_sig'] = self::buildSignature($aArgs); // Set file $aArgs['file'] = "@$sFilename"; // Do the upload $sResponse = call_user_func(array(__CLASS__, self::VIDEOPOST_ENGINE_FSOCK), $aArgs); // Call vimeo.videos.checkUploadStatus to prevent abandoned status return VimeoVideosRequest::checkUploadStatus($sTicket); } private function executeVideopostCall_CURL($aArgs) { // Disable time limit set_time_limit(0); $ch = curl_init(self::VIMEO_UPLOAD_URL); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs); curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME); $data = curl_exec($ch); if(curl_errno($ch)) throw new VimeoRequestException('executeRemoteCall_CURL error: ' . curl_error($ch), curl_errno($ch)); else { curl_close($ch); return unserialize($data); } } /** * Build API query signature * * Composes the signature needed to verify its really us doing the query * * @author Ted Roden * @access private * @param array Additional arguments for the API query * @return string MD5 signature */ private static function buildSignature($aArgs) { $s = ''; // sort by name ksort($aArgs); foreach($aArgs as $k => $v) $s .= $k . $v; return(md5(self::$sApiSecret . $s)); } /** * Build authentication URL * * Easy way to build a correct authentication url. You can use this * to link the user directly to the correct vimeo authentication page. * * @access public * @param string Permission level you need the user to give you (i.e. VimeoBase::PERMISSION_READ) * @return string URL you can use to directly link the user to the vimeo authentication page */ public static function buildAuthenticationUrl($ePermission) { $aArgs = array( 'api_key' => self::$sApiKey, 'perms' => $ePermission ); return self::VIMEO_AUTH_URL . '?api_key=' . self::$sApiKey . '&perms=' . $ePermission . '&api_sig=' . self::buildSignature($aArgs); } /** * Get current logged in user token * * @access public * @return string Token or FALSE if not logged in */ public static function getToken() { return self::$sToken; } /** * Set current logged in user token * * @access public * @param string Authentication token * @return void */ public static function setToken($sToken) { self::$sToken = $sToken; } /** * Clear current logged in user token * * Removes the current logged in user from the cache. Next API query * will be made as clean, not logged in, request. * * @access public * @return void */ public static function clearToken() { self::$sToken = false; } /** * Execute a permit request * * ONLY USED IN SITE-MODE, see howto.autologin.php * Permits the current CURL cached user with your vimeo API application * * @access public * @param string Permission * @return string Vimeo Token */ public function permit($ePermission) { // Disable time limit set_time_limit(0); // Construct login data $aArgs = array( 'api_key' => VimeoBase::$sApiKey, 'perms' => $ePermission, 'accept' => 'yes' ); $ch = curl_init(VimeoBase::buildAuthenticationUrl($ePermission)); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs); curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME); curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true); curl_setopt($ch, CURLOPT_COOKIEFILE, VimeoBase::COOKIE_FILE); curl_setopt($ch, CURLOPT_COOKIEJAR, VimeoBase::COOKIE_FILE); $sPageContent = curl_exec($ch); if(curl_errno($ch)) { throw new VimeoRequestException('Error: Tried to login failed ' . curl_error($ch), curl_errno($ch)); return false; } else { $sResponseUrl = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL); } return $sPageContent; } /** * Ensures that the user is logged in * * ONLY USED IN SITE-MODE, see howto.autologin.php * Ensures the site-account is logged in * * @access public * @param string Username * @param string Password * @return boolean TRUE if user could be logged in, FALSE if an error occured (try manually to see error) */ public function login($sUsername, $sPassword) { // Disable time limit set_time_limit(0); // Construct login data $aArgs = array( 'sign_in[email]' => $sUsername, 'sign_in[password]' => $sPassword, 'redirect' => '' ); $ch = curl_init(VimeoBase::VIMEO_LOGIN_URL); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs); curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME); curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true); curl_setopt($ch, CURLOPT_COOKIEFILE, VimeoBase::COOKIE_FILE); curl_setopt($ch, CURLOPT_COOKIEJAR, VimeoBase::COOKIE_FILE); $sPageContent = curl_exec($ch); if(curl_errno($ch)) { throw new VimeoRequestException('Error: Tried to login failed ' . curl_error($ch), curl_errno($ch)); return false; } else { $sResponseUrl = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL); curl_close($ch); } if(stristr($sResponseUrl, 'log_in') !== false) { // Login failed return false; } else { return true; } } } /** * Vimeo base exception class * * Every exception caused by VimeoBase class will be of this type * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoBaseException extends VimeoException {} /** * Vimeo request exception class * * Exception thrown when requesting the API failed * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoRequestException extends VimeoException {} /** * Vimeo upload exception class * * Exception thrown when uploading a video failed * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoUploadException extends VimeoException {} /** * Vimeo API method handler class * * This class will ensure that only functions can be called if the method is implemented * and the permission is right (p). It also states what the source (s), result (t) and * exception (e) object will be. * * @package SimpleVimeo * @subpackage Base */ class VimeoMethod { private static $aMethods = array( // Vimeo Test methods 'vimeo.test.login' => array( 's' => 'VimeoTestRequest', 't' => 'VimeoTestLoginResponse', 'e' => 'VimeoTestLoginException', 'p' => VimeoBase::PERMISSION_READ), 'vimeo.test.echo' => array( 's' => 'VimeoTestRequest', 't' => 'VimeoTestEchoResponse', 'e' => 'VimeoTestEchoException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.test.null' => array( 's' => 'VimeoTestRequest', 't' => 'VimeoTestNullResponse', 'e' => 'VimeoTestNullException', 'p' => VimeoBase::PERMISSION_READ), // Vimeo Auth methods 'vimeo.auth.getToken' => array( 's' => 'VimeoAuthRequest', 't' => 'VimeoAuthGetTokenResponse', 'e' => 'VimeoAuthGetTokenException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.auth.getFrob' => array( 's' => 'VimeoAuthRequest', 't' => 'VimeoAuthGetFrobResponse', 'e' => 'VimeoAuthGetFrobException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.auth.checkToken' => array( 's' => 'VimeoAuthRequest', 't' => 'VimeoAuthCheckTokenResponse', 'e' => 'VimeoAuthCheckTokenException', 'p' => VimeoBase::PERMISSION_NONE), // Vimeo Videos methods 'vimeo.videos.getList' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetListResponse', 'e' => 'VimeoVideosGetListException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getUploadedList' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetUploadedListResponse', 'e' => 'VimeoVideosGetUploadedListException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getAppearsInList' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetAppearsInListResponse', 'e' => 'VimeoVideosGetAppearsInListException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getSubscriptionsList' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetSubscriptionsListResponse', 'e' => 'VimeoVideosGetSubscriptionsListException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getListByTag' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetListByTagResponse', 'e' => 'VimeoVideosGetListByTagException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getLikeList' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetLikeListResponse', 'e' => 'VimeoVideosGetLikeListException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getContactsList' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetContactsListResponse', 'e' => 'VimeoVideosGetContactsListException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getContactsLikeList' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetContactsLikeListResponse', 'e' => 'VimeoVideosGetContactsLikeListException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.search' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosSearchResponse', 'e' => 'VimeoVideosSearchException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getInfo' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetInfoResponse', 'e' => 'VimeoVideosGetInfoException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.videos.getUploadTicket' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosGetUploadTicketResponse', 'e' => 'VimeoVideosGetUploadTicketException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.checkUploadStatus' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosCheckUploadStatusResponse', 'e' => 'VimeoVideosCheckUploadStatusException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.delete' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosDeleteResponse', 'e' => 'VimeoVideosDeleteException', 'p' => VimeoBase::PERMISSION_DELETE), 'vimeo.videos.setTitle' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosSetTitleResponse', 'e' => 'VimeoVideosSetTitleException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.setCaption' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosSetCaptionResponse', 'e' => 'VimeoVideosSetCaptionException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.setFavorite' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosSetFavoriteResponse', 'e' => 'VimeoVideosSetFavoriteException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.addTags' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosAddTagsResponse', 'e' => 'VimeoVideosAddTagsException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.removeTag' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosRemoveTagResponse', 'e' => 'VimeoVideosRemoveTagException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.clearTags' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosClearTagsResponse', 'e' => 'VimeoVideosClearTagsException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.videos.setPrivacy' => array( 's' => 'VimeoVideosRequest', 't' => 'VimeoVideosSetPrivacyResponse', 'e' => 'VimeoVideosSetPrivacyException', 'p' => VimeoBase::PERMISSION_WRITE), // Vimeo People methods 'vimeo.people.findByUserName' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleFindByUsernameResponse', 'e' => 'VimeoPeopleFindByUsernameException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.people.findByEmail' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleFindByEmailResponse', 'e' => 'VimeoPeopleFindByEmailException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.people.getInfo' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleGetInfoResponse', 'e' => 'VimeoPeopleGetInfoException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.people.getPortraitUrl' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleGetPortraitUrlResponse', 'e' => 'VimeoPeopleGetPortraitUrlException', 'p' => VimeoBase::PERMISSION_NONE), 'vimeo.people.addContact' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleAddContactResponse', 'e' => 'VimeoPeopleAddContactException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.people.removeContact' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleRemoveContactResponse', 'e' => 'VimeoPeopleRemoveContactException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.people.getUploadStatus' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleGetUploadStatusResponse', 'e' => 'VimeoPeopleGetUploadStatusException', 'p' => VimeoBase::PERMISSION_READ), 'vimeo.people.addSubscription' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleAddSubscriptionResponse', 'e' => 'VimeoPeopleAddSubscriptionException', 'p' => VimeoBase::PERMISSION_WRITE), 'vimeo.people.removeSubscription' => array( 's' => 'VimeoPeopleRequest', 't' => 'VimeoPeopleRemoveSubscriptionResponse', 'e' => 'VimeoPeopleRemoveSubscriptionException', 'p' => VimeoBase::PERMISSION_WRITE) ); public static function getSourceObjectForMethod($sMethod) { // Check if the method can be handled self::checkMethod($sMethod); return self::$aMethods[$sMethod]['s']; } public static function getTargetObjectForMethod($sMethod) { // Check if the method can be handled self::checkMethod($sMethod); return self::$aMethods[$sMethod]['t']; } public static function getExceptionObjectForMethod($sMethod) { // Check if the method can be handled self::checkMethod($sMethod); return self::$aMethods[$sMethod]['e']; } public static function getPermissionRequirementForMethod($sMethod) { // Check if the method can be handled self::checkMethod($sMethod); return self::$aMethods[$sMethod]['p']; } public static function checkMethod($sMethod) { // Check if the method can be handled if(!isset(self::$aMethods[$sMethod])) { throw new VimeoMethodException('Unhandled vimeo method "' . $sMethod . '" given', 2); } } } /** * Vimeo method exception class * * Every exception caused by VimeoMethod class will be of this type * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoMethodException extends Exception {} /* * Abstract class constructs that the whole api stuff will be based on */ /** * Vimeo exception class * * Every exception the whole SimpleVimeo throws will be extended of this base * class. You can extend this one to alter all exceptions. * * @package SimpleVimeo * @subpackage Exceptions * @abstract */ abstract class VimeoException extends Exception {} /** * Vimeo array of object handler class * * This class is for array of object handling. i.e.: An array of video objects. * It ensures that you can work with foreach and count without getting into a hassle. * * @package SimpleVimeo * @subpackage Base * @abstract */ abstract class VimeoObjectList implements Iterator, Countable { /** * Array for instanced objects * @var array */ private $aInstances = array(); /** * Integer how many results * @var integer */ private $iCount = 0; /** * Class name * @var string */ private $sClassName; private $aIDs = array(); /** * Constructor * * @access public * @return void */ public function __construct() { // Parse class name $this->sClassName = str_replace('List', '', get_class($this)); } /** * Add object to array * * @access public * @param object Object to be added to array * @param integer Array index to be used for the given object * @return void */ public function add($oObject, $iID = false) { if($iID !== false) { $this->aInstances[$iID] = $oObject; } else { $this->aInstances[] = $oObject; } $this->aIDs[] = $iID; $this->iCount++; } /** * Returns all array indexes for further parsing * * @access public * @return array Array with object array indexes */ public function getAllUniqueIDs() { return $this->getIDs(); } /** * @ignore */ public function rewind() { reset($this->aInstances); } /** * @ignore */ public function current() { return current($this->aInstances); } /** * @ignore */ public function key() { return key($this->aInstances); } /** * @ignore */ public function next() { return next($this->aInstances); } /** * @ignore */ public function valid() { return $this->current() !== FALSE; } /** * @ignore */ public function count() { return $this->iCount; } } /** * Vimeo request class * * Every API query collection class will be based on this. * * @package SimpleVimeo * @subpackage ApiRequest * @abstract */ abstract class VimeoRequest {} /** * Vimeo response class * * Every API response class will be based on this. It also handles * everytime response variables like if the query was successfull and * the generation time. * * @package SimpleVimeo * @subpackage ApiResponse * @abstract */ abstract class VimeoResponse { private $bStatus = false; private $fPerformance = false; private $iErrorCode = false; private $oError = false; /** * Constructor * * Parses the API response * You dont need to pass a response if you need to give a hint your coding tool for code completion * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { if($aResponse) { // Parse status $this->setStatus($aResponse->stat); // Parse performance $this->fPerformance = (float) $aResponse->generated_in; // Parse error information if(!$this->bStatus) { $this->oError = new VimeoErrorEntity($aResponse->err->code, $aResponse->err->msg); } } } private function setStatus($sStatus) { if($sStatus === 'ok') { $this->bStatus = true; } } public function getStatus() { return $this->bStatus; } public function getPerformance() { return $this->fPerformance; } public function getError() { return $this->oError; } } /* * Entity classes for default instances of users etc. they are always the same * and their array of object handlers */ /** * Vimeo API error entity class * * Implements API delivered error entities into an PHP 5 object with given result parameters. * * @package SimpleVimeo * @subpackage Entities */ class VimeoErrorEntity { private $iErrorCode = false; private $sErrorMessage = false; public function __construct($iErrorCode, $sErrorMessage) { $this->iErrorCode = $iErrorCode; $this->sErrorMessage = $sErrorMessage; } public function getCode() { return $this->iErrorCode; } public function getMessage() { return $this->sErrorMessage; } } /** * Vimeo API user entity class * * Implements API delivered user entities into an PHP 5 object with given result parameters. * * @package SimpleVimeo * @subpackage Entities */ class VimeoUserEntity { private $iUserNsId = false; private $iUserId = false; private $sUsername = false; private $sFullname = false; // Optional information when vimeo.person.getInfo is called private $sLocation = false; private $sUrl = false; private $iNumberOfContacts = false; private $iNumberOfUploads = false; private $iNumberOfLikes = false; private $iNumberOfVideos = false; private $iNumberOfVideosAppearsIn = false; private $sProfileUrl = false; private $sVideosUrl = false; public function __construct($aResponseSnippet) { if(isset($aResponseSnippet->id)) { $this->iUserId = $aResponseSnippet->id; } if(isset($aResponseSnippet->nsid)) { $this->iUserNsId = $aResponseSnippet->nsid; } if(isset($aResponseSnippet->username)) { $this->sUsername = $aResponseSnippet->username; } if(isset($aResponseSnippet->fullname)) { $this->sFullname = $aResponseSnippet->fullname; } if(isset($aResponseSnippet->display_name)) { $this->sFullname = $aResponseSnippet->display_name; } // Optional stuff if(isset($aResponseSnippet->location)) { $this->sLocation = $aResponseSnippet->location; } if(isset($aResponseSnippet->url)) { $this->sUrl = $aResponseSnippet->url; } if(isset($aResponseSnippet->number_of_contacts)) { $this->iNumberOfContacts = $aResponseSnippet->number_of_contacts; } if(isset($aResponseSnippet->number_of_uploads)) { $this->iNumberOfUploads = $aResponseSnippet->number_of_uploads; } if(isset($aResponseSnippet->number_of_likes)) { $this->iNumberOfLikes = $aResponseSnippet->number_of_likes; } if(isset($aResponseSnippet->number_of_videos)) { $this->iNumberOfVideos = $aResponseSnippet->number_of_videos; } if(isset($aResponseSnippet->number_of_videos_appears_in)) { $this->iNumberOfVideosAppearsIn = $aResponseSnippet->number_of_videos_appears_in; } if(isset($aResponseSnippet->profileurl)) { $this->sProfileUrl = $aResponseSnippet->profileurl; } if(isset($aResponseSnippet->videosurl)) { $this->sVideosUrl = $aResponseSnippet->videosurl; } } public function getNsID() { return $this->iUserNsId; } public function getID() { return $this->iUserId; } public function getUsername() { return $this->sUsername; } public function getFullname() { return $this->sFullname; } public function getLocation() { return $this->sLocation; } public function getUrl() { return $this->sUrl; } public function getNumberOfContacts() { return $this->iNumberOfContacts; } public function getNumberOfUploads() { return $this->iNumberOfUploads; } public function getNumberOfLikes() { return $this->iNumberOfLikes; } public function getNumberOfVideos() { return $this->iNumberOfVideos; } public function getNumberOfVideosAppearsIn() { return $this->iNumberOfVideosAppearsIn; } public function getProfileUrl() { return $this->sProfileUrl; } public function getVideosUrl() { return $this->sVideosUrl; } } /** * Vimeo API video entity class * * Implements API delivered video into an PHP 5 object with given result parameters. * * @package SimpleVimeo * @subpackage Entities */ class VimeoVideoEntity { private $iID = false; private $ePrivacy = false; private $bIsUploading = false; private $bIsTranscoding = false; private $bIsHD = false; private $sTitle = false; private $sCaption = false; private $iUploadTime = false; private $iNumberOfLikes = false; private $iNumberOfPlays = false; private $iNumberOfComments = false; private $sUrl = false; private $iWidth = false; private $iHeight = false; private $oOwner = false; private $oTagList = false; private $oThumbnailList = false; public function __construct($aResponseSnippet = false) { if($aResponseSnippet) { // Set basic information $this->iID = $aResponseSnippet->id; $this->ePrivacy = $aResponseSnippet->privacy; $this->bIsUploading = $aResponseSnippet->is_uploading; $this->bIsTranscoding = $aResponseSnippet->is_transcoding; $this->bIsHD = $aResponseSnippet->is_hd; $this->sTitle = $aResponseSnippet->title; $this->sCaption = $aResponseSnippet->caption; $this->iUploadTime = strtotime($aResponseSnippet->upload_date); $this->iNumberOfLikes = (int) $aResponseSnippet->number_of_likes; $this->iNumberOfPlays = (int) $aResponseSnippet->number_of_plays; $this->iNumberOfComments = (int) $aResponseSnippet->number_of_comments; $this->sUrl = $aResponseSnippet->urls->url->_content; $this->iWidth = (int) $aResponseSnippet->width; $this->iHeight = (int) $aResponseSnippet->height; $this->oOwner = new VimeoUserEntity($aResponseSnippet->owner); // Parse Tags $this->oTagList = new VimeoTagList(); if(isset($aResponseSnippet->tags->tag)) { foreach($aResponseSnippet->tags->tag as $aTagInformation) { $oTag = new VimeoTagEntity($aTagInformation); $this->oTagList->add($oTag, $oTag->getID()); } } // Parse Thumbnails $this->oThumbnailList = new VimeoThumbnailList(); if(isset($aResponseSnippet->thumbnails->thumbnail)) { foreach($aResponseSnippet->thumbnails->thumbnail as $aThumbnailInformation) { $oThumbnail = new VimeoThumbnailEntity($aThumbnailInformation); $this->oThumbnailList->add($oThumbnail, ($oThumbnail->getWidth() * $oThumbnail->getHeight())); } } } } public function getID() { return $this->iID; } public function getPrivacy() { return $this->ePrivacy; } public function isUploading() { return $this->bIsUploading; } public function isTranscoding() { return $this->bIsTranscoding; } public function isHD() { return $this->bIsHD; } public function getTitle() { return $this->sTitle; } public function getCaption() { return $this->sCaption; } public function getUploadTimestamp() { return $this->iUploadTime; } public function getNumberOfLikes() { return (int) $this->iNumberOfLikes; } public function getNumberOfPlays() { return (int) $this->iNumberOfPlays; } public function getNumberOfComments() { return (int) $this->iNumberOfComments; } public function getWidth() { return (int) $this->iWidth; } public function getHeight() { return (int) $this->iHeight; } public function getOwner() { return $this->oOwner; } public function getTags() { return $this->oTagList; } public function getUrl() { return $this->sUrl; } public function getThumbnails() { return $this->oThumbnailList; } } /** * Vimeo API video list class * * Implements API delivered video list entities into an PHP 5 array of objects. * * @package SimpleVimeo * @subpackage Lists */ class VimeoVideoList extends VimeoObjectList {} /** * Vimeo API tag entity class * * Implements API delivered tag entities into an PHP 5 object with given result parameters. * * @package SimpleVimeo * @subpackage Entities */ class VimeoTagEntity { private $iID = false; private $sContent = false; public function __construct($aResponseSnippet = false) { if($aResponseSnippet) { $this->iID = $aResponseSnippet->id; $this->sContent = $aResponseSnippet->_content; } } public function getID() { return $this->iID; } public function getTag() { return $this->sContent; } } /** * Vimeo API tag list class * * Implements API delivered tag list entities into an PHP 5 array of objects. * * @package SimpleVimeo * @subpackage Lists */ class VimeoTagList extends VimeoObjectList {} /** * Vimeo API thumbnail entity class * * Implements API delivered thumbnail entities into an PHP 5 object with given result parameters. * * @package SimpleVimeo * @subpackage Entities */ class VimeoThumbnailEntity { private $iWidth = false; private $iHeight = false; private $sContent = false; public function __construct($aResponseSnippet = false) { if($aResponseSnippet) { $this->iWidth = (int) $aResponseSnippet->width; $this->iHeight = (int) $aResponseSnippet->height; $this->sContent = $aResponseSnippet->_content; } } public function getWidth() { return (int) $this->iWidth; } public function getHeight() { return (int) $this->iHeight; } public function getImageContent() { return $this->sContent; } } /** * Vimeo API thumbnail list class * * Implements API delivered thumbnail list entities into an PHP 5 array of objects. * * @package SimpleVimeo * @subpackage Lists */ class VimeoThumbnailList extends VimeoObjectList { public function getByWidth($iWidth, $bAlsoLower = false) { /** * @todo */ } public function getByHeight($iHeight, $bAlsoLower = false) { /** * @todo */ } public function getByWidthAndHeight($iWidth, $iHeight, $bAlsoLower = false) { /** * @todo */ } } /* * vimeo.test.* methods */ /** * Vimeo Test request handler class * * Implements all API queries in the vimeo.test.* category * * @package SimpleVimeo * @subpackage ApiRequest */ class VimeoTestRequest extends VimeoRequest { /** * Is the user logged in? * * @access public * @return VimeoTestLoginResponse */ public function login() { return VimeoBase::executeRemoteCall('vimeo.test.login'); } /** * This will just repeat back any parameters that you send. * * @access public * @param array Additional arguments that need to be passed to the API * @return VimeoTestEchoResponse */ public function echoback($aArgs) { return VimeoBase::executeRemoteCall('vimeo.test.echo', $aArgs); } /** * This is just a simple null/ping test... * * @access public * @return VimeoTestNullResponse */ public function ping() { return VimeoBase::executeRemoteCall('vimeo.test.null'); } } /** * Vimeo Test Login response handler class * * Handles the API response for vimeo.test.login queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoTestLoginResponse extends VimeoResponse {} /** * Vimeo Test Login exception handler class * * Handles exceptions caused by API response for vimeo.test.login queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoTestLoginException extends VimeoException {} /** * Vimeo Test Echo response handler class * * Handles the API response for vimeo.test.echo queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoTestEchoResponse extends VimeoResponse { private $aArgs = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { parent::__construct($aResponse); $this->aArgs = get_object_vars($aResponse); // Unset default response stuff if(isset($this->aArgs['stat'])) unset($this->aArgs['stat']); if(isset($this->aArgs['generated_in'])) unset($this->aArgs['generated_in']); } /** * Returns an array of variables the request bounced back * * @access public * @return array Echoed variables */ public function getResponseArray() { return $this->aArgs; } } /** * Vimeo Test Echo exception handler class * * Handles exceptions caused by API response for vimeo.test.echo queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoTestEchoException extends VimeoException {} /** * Vimeo Test Null response handler class * * Handles the API response for vimeo.test.null queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoTestNullResponse extends VimeoResponse {} /** * Vimeo Test Null exception handler class * * Handles exceptions caused by API response for vimeo.test.null queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoTestNullException extends VimeoException {} /* * vimeo.auth.* methods */ /** * Vimeo Auth request handler class * * Implements all API queries in the vimeo.auth.* category * * @package SimpleVimeo * @subpackage ApiRequest */ class VimeoAuthRequest extends VimeoRequest { /** * Get Token * * @access public * @param string Frob taken from the vimeo authentication * @return VimeoAuthGetTokenResponse */ public function getToken($sFrob) { $aArgs = array( 'frob' => $sFrob ); return VimeoBase::executeRemoteCall('vimeo.auth.getToken', $aArgs); } /** * Check Token * * Checks the validity of the token. Returns the user associated with it. * Returns the same as vimeo.auth.getToken * * @access public * @param string Authentication token * @return VimeoAuthCheckTokenResponse */ public function checkToken($sToken = false) { if(!$sToken) $sToken = VimeoBase::getToken(); $aArgs = array( 'auth_token' => $sToken ); return VimeoBase::executeRemoteCall('vimeo.auth.checkToken', $aArgs); } /** * Get Frob * * This is generally used by desktop applications. If the user doesn't already have * a token, you'll need to get the frob, send it to us at /services/auth. Then, * after the user, clicks continue on your app, you call vimeo.auth.getToken($frob) * and we give you the actual token. * * @access public * @return VimeoAuthGetFrobResponse */ public function getFrob() { return VimeoBase::executeRemoteCall('vimeo.auth.getFrob'); } } /** * Vimeo Auth GetToken response handler class * * Handles the API response for vimeo.auth.getToken queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoAuthGetTokenResponse extends VimeoResponse { private $sToken = false; private $ePermission = false; private $oUser = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse) { parent::__construct($aResponse); $this->sToken = $aResponse->auth->token; $this->ePermission = $aResponse->auth->perms; $this->oUser = new VimeoUserEntity($aResponse->auth->user); } /** * Get token value * * @access public * @return token */ public function getToken() { return $this->sToken; } /** * Get permission value * * @access public * @return permission */ public function getPermission() { return $this->ePermission; } /** * Get user information object * * @access public * @return VimeoUserEntity */ public function getUser() { return $this->oUser; } } /** * Vimeo Auth GetToken exception handler class * * Handles exceptions caused by API response for vimeo.auth.getToken queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoAuthGetTokenException extends Exception {} /** * Vimeo Auth CheckToken response handler class * * Handles the API response for vimeo.auth.checkToken queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoAuthCheckTokenResponse extends VimeoAuthGetTokenResponse {} /** * Vimeo Auth CheckToken exception handler class * * Handles exceptions caused by API response for vimeo.auth.checkToken queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoAuthCheckTokenException extends VimeoAuthGetTokenException {} /** * Vimeo Auth GetFrob response handler class * * Handles the API response for vimeo.auth.getFrob queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoAuthGetFrobResponse extends VimeoResponse { private $sFrob = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse) { parent::__construct($aResponse); $this->sFrob = $aResponse->frob; } /** * Get Frob value * * @access public * @return frob */ public function getFrob() { return $this->sFrob; } } /** * Vimeo Auth GetFrob exception handler class * * Handles exceptions caused by API response for vimeo.auth.getFrob queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoAuthGetFrobException extends VimeoException {} /** * vimeo.videos.* methods */ /** * Vimeo Videos request handler class * * Implements all API queries in the vimeo.videos.* category * * @package SimpleVimeo * @subpackage ApiRequest */ class VimeoVideosRequest extends VimeoRequest { const PRIVACY_ANYBODY = 'anybody'; const PRIVACY_CONTACTS = 'contacts'; const PRIVACY_NOBODY = 'nobody'; const PRIVACY_USERS = 'users'; /** * Search videos! * * If the calling user is logged in, this will return information that calling user * has access to (including private videos). If the calling user is not authenticated, * this will only return public information, or a permission denied error if none is available. * * @access public * @param string Search query * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param boolean If TRUE, we'll only search the users contacts. If this is set, you must specifiy a User ID. Otherwise it will be ignored without error. * @param integer ow many results per page? * @return VimeoVideosSearchResponse */ public function search($sQuery, $iUserID = false, $bContactsOnly = false, $iItemsPerPage = false) { // Pass query (required) $aArgs = array( 'query' => $sQuery ); // Pass user if($iUserID) { $aArgs['user_id'] = $iUserID; } // Pass contacts if($bContactsOnly) { $aArgs['contacts_only'] = $bContactsOnly; } // Pass items if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.search', $aArgs); } /** * This gets a list of videos for the specified user. * * This is the functionality of "My Videos" or "Ted's Videos." At the moment, this is the same list * as vimeo.videos.getAppearsInList. If you need uploaded or appears in, those are available too. * * @access public * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetListResponse */ public function getList($iUserID, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'user_id' => $iUserID ); if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getList', $aArgs); } /** * This gets a list of videos uploaded by the specified user. * * If the calling user is logged in, this will return information that calling user has access to * (including private videos). If the calling user is not authenticated, this will only return * public information, or a permission denied error if none is available. * * @access public * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetUploadedListResponse */ public function getUploadedList($iUserID, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'user_id' => $iUserID ); if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getUploadedList', $aArgs); } /** * This gets a list of videos that the specified user appears in. * * If the calling user is logged in, this will return information that calling user has access * to (including private videos). If the calling user is not authenticated, this will only return * public information, or a permission denied error if none is available. * * @access public * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetAppearsInListResponse */ public function getAppearsInList($iUserID, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'user_id' => $iUserID ); if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getAppearsInList', $aArgs); } /** * This gets a list of subscribed videos for a particular user. * * If the calling user is logged in, this will return information that calling user * has access to (including private videos). If the calling user is not authenticated, * this will only return public information, or a permission denied error if none is available. * * @access public * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetSubscriptionsListResponse */ public function getSubscriptionsList($iUserID, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'user_id' => $iUserID ); if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getSubscriptionsList', $aArgs); } /** * This gets a list of videos by tag * * If you specify a user_id, we'll only get video uploaded by that user with the specified tag. * If the calling user is logged in, this will return information that calling user has access * to (including private videos). If the calling user is not authenticated, this will only * return public information, or a permission denied error if none is available. * * @access public * @param string A single tag: "cat" "new york" "cheese" * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetListByTagResponse */ public function getListByTag($sTag, $iUserID = false, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'tag' => $sTag ); if($iUserID) { $aArgs['user_id'] = $iUserID; } if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getListByTag', $aArgs); } /** * Get a list of videos that the specified user likes. * * If the calling user is logged in, this will return information that calling user has * access to (including private videos). If the calling user is not authenticated, this will * only return public information, or a permission denied error if none is available. * * @access public * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetLikeListResponse */ public function getLikeList($iUserID, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'user_id' => $iUserID ); if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getLikeList', $aArgs); } /** * Get a list of videos made by the contacts of a specific user. * * If the calling user is logged in, this will return information that calling user has * access to (including private videos). If the calling user is not authenticated, this will * only return public information, or a permission denied error if none is available. * * @access public * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetContactsListResponse */ public function getContactsList($iUserID, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'user_id' => $iUserID ); if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getContactsList', $aArgs); } /** * Get a list of videos that the specified users contacts like. * * If the calling user is logged in, this will return information that calling user has * access to (including private videos). If the calling user is not authenticated, this will * only return public information, or a permission denied error if none is available. * * @access public * @param integer User ID, this can be the ID number (151542) or the username (ted) * @param integer Which page to show. * @param integer How many results per page? * @return VimeoVideosGetContactsLikeListResponse */ public function getContactsLikeList($iUserID, $iPage = false, $iItemsPerPage = false) { // Extend query $aArgs = array( 'user_id' => $iUserID ); if($iPage) { $aArgs['page'] = $iPage; } if($iItemsPerPage) { $aArgs['per_page'] = $iItemsPerPage; } // Please deliver full response so we can handle videos with unified classes $aArgs['fullResponse'] = 1; return VimeoBase::executeRemoteCall('vimeo.videos.getContactsLikeList', $aArgs); } /** * Get all kinds of information about a photo. * * If the calling user is logged in, this will return information that calling user has * access to (including private videos). If the calling user is not authenticated, this will * only return public information, or a permission denied error if none is available. * * @access public * @param integer Video ID * @return VimeoVideosGetInfoResponse */ public function getInfo($iVideoID) { // Extend query $aArgs = array( 'video_id' => $iVideoID ); return VimeoBase::executeRemoteCall('vimeo.videos.getInfo', $aArgs); } /** * Generate a new upload Ticket. * * You'll need to pass this to the uploader. It's only good for one upload, only good for one user. * * @access public * @return VimeoVideosGetUploadTicketResponse */ public function getUploadTicket() { return VimeoBase::executeRemoteCall('vimeo.videos.getUploadTicket'); } /** * Check the status of an upload started via the API * * This is how you get the video_id of a clip uploaded from the API * If you never call this to check in, we assume it was abandoned and don't process it * * @access public * @param string The ticket number of the upload * @return VimeoVideosCheckUploadStatusResponse */ public function checkUploadStatus($sTicket) { $aArgs = array( 'ticket_id' => $sTicket ); return VimeoBase::executeRemoteCall('vimeo.videos.checkUploadStatus', $aArgs); } /** * Simple video upload * * @access public * @param string Absolute path to file * @param string Existing ticket or false to generate a new one * @return VimeoVideosCheckUploadStatusResponse */ public function doUpload($sFilename, $sTicket = false) { return VimeoBase::executeVideopostCall($sFilename, $sTicket); } /** * Delete a video * * The authenticated user must own the video and have granted delete permission * * @access public * @param integer Video ID * @return VimeoVideosDeleteResponse */ public function delete($iVideoID) { $aArgs = array( 'video_id' => $iVideoID ); return VimeoBase::executeRemoteCall('vimeo.videos.delete', $aArgs); } /** * Set the title of a video (overwrites previous title) * * @access public * @param integer Video ID * @param string Title * @return VimeoVideosSetTitleResponse */ public function setTitle($iVideoID, $sVideoTitle) { $aArgs = array( 'video_id' => $iVideoID, 'title' => $sVideoTitle ); return VimeoBase::executeRemoteCall('vimeo.videos.setTitle', $aArgs); } /** * Set a new caption for a video (overwrites previous caption) * * @access public * @param integer Video ID * @param string Caption * @return VimeoVideosSetCaptionResponse */ public function setCaption($iVideoID, $sVideoCaption) { $aArgs = array( 'video_id' => $iVideoID, 'caption' => $sVideoCaption ); return VimeoBase::executeRemoteCall('vimeo.videos.setCaption', $aArgs); } /** * Set a video as a favorite. * * @access public * @param integer Video ID * @param boolean TRUE to favorite, FALSE to return to normal * @return VimeoVideosSetFavoriteResponse */ public function setFavorite($iVideoID, $bFavorite = true) { $aArgs = array( 'video_id' => $iVideoID, 'favorite' => (int) $bFavorite ); return VimeoBase::executeRemoteCall('vimeo.videos.setFavorite', $aArgs); } /** * Add specified tags to the video, this does not replace any tags. * * Tags should be comma separated lists. * * If the calling user is logged in, this will return information that calling * user has access to (including private videos). If the calling user is not authenticated, * this will only return public information, or a permission denied error if none is available. * * @access public * @param integer Video ID * @param mixed Array with tags or Comma separated list of tags ("lions, tigers, bears") * @return VimeoVideosAddTagsResponse */ public function addTags($iVideoID, $mTags) { // Catch array of tags if(is_array($mTags)) { $mTags = implode(',', $mTags); } // Prepare arguments $aArgs = array( 'video_id' => $iVideoID, 'tags' => $mTags ); return VimeoBase::executeRemoteCall('vimeo.videos.addTags', $aArgs); } /** * Remove specified tag from the video. * * @access public * @param integer Video ID * @param integer Tag ID, this should be a tag id returned by vimeo.videos.getInfo * @return VimeoVideosRemoveTagResponse */ public function removeTag($iVideoID, $iTagID) { $aArgs = array( 'video_id' => $iVideoID, 'tag_id' => $iTagID ); return VimeoBase::executeRemoteCall('vimeo.videos.removeTag', $aArgs); } /** * Remove ALL of the tags from the video * * @access public * @param integer Video ID * @return VimeoVideosClearTags */ public function clearTags($iVideoID) { $aArgs = array( 'video_id' => $iVideoID ); return VimeoBase::executeRemoteCall('vimeo.videos.clearTags', $aArgs); } /** * Set the privacy of the video * * @access public * @param integer Video ID * @param integer Privacy enum see VimeoVideosRequest::PRIVACY_* * @param mixed Array or comma separated list of users who can view the video. PRIVACY_USERS must be set. */ public function setPrivacy($iVideoID, $ePrivacy, $mUsers = array()) { // Catch array of users if(is_array($mUsers)) { $mUsers = implode(', ', $mUsers); } $aArgs = array( 'video_id' => $iVideoID, 'privacy' => $ePrivacy, 'users' => $mUsers ); return VimeoBase::executeRemoteCall('vimeo.videos.setPrivacy', $aArgs); } } /** * Vimeo Videos Search response handler class * * Handles the API response for vimeo.videos.search queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosSearchResponse extends VimeoResponse { private $iPage = false; private $iItemsPerPage = false; private $iOnThisPage = false; private $aoVideos = array(); /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse) { parent::__construct($aResponse); // Parse information if($aResponse && isset($aResponse->videos) && $this->getStatus()) { // Create an video list instance $this->aoVideos = new VimeoVideoList(); // Page information $this->iPage = $aResponse->videos->page; $this->iItemsPerPage = $aResponse->videos->perpage; $this->iOnThisPage = $aResponse->videos->on_this_page; // Parse videos if(isset($aResponse->videos->video)) { // We should check if the subelement is an object (single hit) or an result array (multiple hits) if(is_array($aResponse->videos->video)) { // We got a couple of results $aParseableData = $aResponse->videos->video; } else { // We only got one result $aParseableData = array( 0 => $aResponse->videos->video ); } // Parse the results foreach($aParseableData as $aVideoInformation) { $oVideo = new VimeoVideoEntity($aVideoInformation); $this->aoVideos->add($oVideo, $oVideo->getID()); } } } } /** * Current page * * @access public * @return integer Page number */ public function getPage() { return $this->iPage; } /** * Items per page * * @access public * @return integer Items per page */ public function getItemsPerPage() { return $this->iItemsPerPage; } /** * Items on the current page * * @access public * @return integer Items on the current page */ public function getOnThisPage() { return $this->iOnThisPage; } /** * Get array of video objects * * @access public * @return array Video objects */ public function getVideos() { return $this->aoVideos; } } /** * Vimeo Videos Search exception handler class * * Handles exceptions caused by API response for vimeo.videos.search queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosSearchException extends VimeoException {} /** * Vimeo Videos GetList response handler class * * Handles the API response for vimeo.videos.getList queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetListResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos Search exception handler class * * Handles exceptions caused by API response for vimeo.videos.search queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetListException extends VimeoException {} /** * Vimeo Videos GetUploadedList response handler class * * Handles the API response for vimeo.videos.getUploadedList queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetUploadedListResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos GetUploadedList exception handler class * * Handles exceptions caused by API response for vimeo.videos.getUploadedList queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetUploadedListException extends VimeoException {} /** * Vimeo Videos GetAppearsInList response handler class * * Handles the API response for vimeo.videos.getAppearsInList queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetAppearsInListResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos GetAppearsInList exception handler class * * Handles exceptions caused by API response for vimeo.videos.getAppearsInList queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetAppearsInListException extends VimeoException {} /** * Vimeo Videos GetSubscriptionsList response handler class * * Handles the API response for vimeo.videos.getSubscriptionsList queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetSubscriptionsListResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos GetSubscriptionsList exception handler class * * Handles exceptions caused by API response for vimeo.videos.getSubscriptionsList queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetSubscriptionsListException extends VimeoException {} /** * Vimeo Videos GetListByTag response handler class * * Handles the API response for vimeo.videos.getListByTag queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetListByTagResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos GetListByTag exception handler class * * Handles exceptions caused by API response for vimeo.videos.getListByTag queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetListByTagException extends VimeoException {} /** * Vimeo Videos GetLikeList response handler class * * Handles the API response for vimeo.videos.getLikeList queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetLikeListResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos GetLikeList exception handler class * * Handles exceptions caused by API response for vimeo.videos.getLikeList queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetLikeListException extends VimeoException {} /** * Vimeo Videos GetContactsList response handler class * * Handles the API response for vimeo.videos.getContactsList queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetContactsListResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos GetContactsList exception handler class * * Handles exceptions caused by API response for vimeo.videos.getContactsList queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetContactsListException extends VimeoException {} /** * Vimeo Videos getContactsLikeList response handler class * * Handles the API response for vimeo.videos.getContactsLikeList queries. * Currently the response is exact the same as vimeo.videos.search * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosgetContactsLikeListResponse extends VimeoVideosSearchResponse {} /** * Vimeo Videos getContactsLikeList exception handler class * * Handles exceptions caused by API response for vimeo.videos.getContactsLikeList queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetContactsLikeListException extends VimeoException {} /** * Vimeo Videos GetInfo response handler class * * Handles the API response for vimeo.videos.getInfo queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetInfoResponse extends VimeoResponse { private $oVideo = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse) { parent::__construct($aResponse); $this->oVideo = new VimeoVideoEntity($aResponse->video); } /** * Get video information as object * * @access public * @return VimeoVideoEntity */ public function getVideo() { return $this->oVideo; } } /** * Vimeo Videos GetInfo exception handler class * * Handles exceptions caused by API response for vimeo.videos.getInfo queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetInfoException extends VimeoException {} /** * Vimeo Videos getUploadTicket response handler class * * Handles the API response for vimeo.videos.getUploadTicket queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosGetUploadTicketResponse extends VimeoResponse { private $sTicket = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { parent::__construct($aResponse); $this->sTicket = $aResponse->ticket->id; } /** * Get generated upload ticket * * @access public * @return string The ticket number of the upload */ public function getTicket() { return $this->sTicket; } } /** * Vimeo Videos getUploadTicket exception handler class * * Handles exceptions caused by API response for vimeo.videos.getUploadTicket queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosGetUploadTicketException extends VimeoException {} /** * Vimeo Videos checkUploadStatus response handler class * * Handles the API response for vimeo.videos.checkUploadStatus queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosCheckUploadStatusResponse extends VimeoResponse { private $sTicket = false; private $iVideoID = false; private $bIsUploading = false; private $bIsTranscoding = false; private $iTranscodingProgress = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { parent::__construct($aResponse); $this->sTicket = $aResponse->ticket->id; $this->iVideoID = $aResponse->ticket->video_id; $this->bIsUploading = (bool) $aResponse->ticket->is_uploading; $this->bIsTranscoding = (bool) $aResponse->ticket->is_transcoding; $this->iTranscodingProgress = $aResponse->ticket->transcoding_progress; } /** * Get Ticket * * @access public * @return string Ticket */ public function getTicket() { return $this->sTicket; } /** * Get Video ID * * @access public * @return integer Video ID */ public function getVideoID() { return $this->iVideoID; } /** * Is the video uploading? * * @access public * @return boolean TRUE if uploading, FALSE if not */ public function isUploading() { return $this->bIsUploading; } /** * Is the video transcoding? * * Also check getTranscodingProgress() for percentage in transcoding * * @access public * @return boolean TRUE if uploading, FALSE if not */ public function isTranscoding() { return $this->bIsTranscoding; } /** * Get the transcoding progress * * Should only be called if isTranscoding() returns true * * @access public * @return integer Percentage */ public function getTranscodingProgress() { return $this->iTranscodingProgress; } } /** * Vimeo Videos checkUploadStatus exception handler class * * Handles exceptions caused by API response for vimeo.videos.checkUploadStatus queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosCheckUploadStatusException extends VimeoException {} /** * Vimeo Videos delete response handler class * * Handles the API response for vimeo.videos.delete queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosDeleteResponse extends VimeoResponse {} /** * Vimeo Videos delete exception handler class * * Handles exceptions caused by API response for vimeo.videos.delete queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosDeleteException extends VimeoException {} /** * Vimeo Videos setTitle response handler class * * Handles the API response for vimeo.videos.setTitle queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosSetTitleResponse extends VimeoResponse {} /** * Vimeo Videos setTitle exception handler class * * Handles exceptions caused by API response for vimeo.videos.setTitle queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosSetTitleException extends VimeoException {} /** * Vimeo Videos setCaption response handler class * * Handles the API response for vimeo.videos.setCaption queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosSetCaptionResponse extends VimeoResponse {} /** * Vimeo Videos setCaption exception handler class * * Handles exceptions caused by API response for vimeo.videos.setCaption queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosSetCaptionException extends VimeoException {} /** * Vimeo Videos setFavorite response handler class * * Handles the API response for vimeo.videos.setFavorite queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosSetFavoriteResponse extends VimeoResponse {} /** * Vimeo Videos setFavorite exception handler class * * Handles exceptions caused by API response for vimeo.videos.setFavorite queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosSetFavoriteException extends VimeoException {} /** * Vimeo Videos addTags response handler class * * Handles the API response for vimeo.videos.addTags queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosAddTagsResponse extends VimeoResponse {} /** * Vimeo Videos addTags exception handler class * * Handles exceptions caused by API response for vimeo.videos.addTags queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosAddTagsException extends VimeoException {} /** * Vimeo Videos removeTag response handler class * * Handles the API response for vimeo.videos.removeTag queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosRemoveTagResponse extends VimeoResponse {} /** * Vimeo Videos removeTag exception handler class * * Handles exceptions caused by API response for vimeo.videos.removeTag queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosRemoveTagException extends VimeoException {} /** * Vimeo Videos clearTags response handler class * * Handles the API response for vimeo.videos.clearTags queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosClearTagsResponse extends VimeoResponse {} /** * Vimeo Videos clearTags exception handler class * * Handles exceptions caused by API response for vimeo.videos.clearTags queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosClearTagsException extends VimeoException {} /** * Vimeo Videos setPrivacy response handler class * * Handles the API response for vimeo.videos.setPrivacy queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoVideosSetPrivacyResponse extends VimeoResponse {} /** * Vimeo Videos setPrivacy exception handler class * * Handles exceptions caused by API response for vimeo.videos.setPrivacy queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoVideosSetPrivacyException extends VimeoException {} /** * vimeo.people.* methods */ /** * Vimeo People request handler class * * Implements all API queries in the vimeo.people.* category * * @package SimpleVimeo * @subpackage ApiRequest */ class VimeoPeopleRequest extends VimeoRequest { const TYPE_LIKES = 'likes'; const TYPE_APPEARS = 'appears'; const TYPE_BOTH = 'likes,appears'; /** * Get a user id and full/display name with a username. * * You shouldn't need this to get the User ID, we allow you to use the * username instead of User ID everywhere, it's much nicer that way. * * @access public * @param string The username to lookup * @return VimeoPeopleFindByUsernameResponse */ public function findByUsername($sUsername) { $aArgs = array( 'username' => $sUsername ); return VimeoBase::executeRemoteCall('vimeo.people.findByUserName', $aArgs); } /** * Get tons of info about a user. * * @access public * @param integer The id of the user we want. * @return VimeoPeopleGetInfoResponse */ public function getInfo($iUserID) { $aArgs = array( 'user_id' => $iUserID ); return VimeoBase::executeRemoteCall('vimeo.people.getInfo', $aArgs); } /** * Get a user id and full/display name via an Email Address. * * You shouldn't need to use this to get the User ID, we allow you * to use the username instead of User ID everywhere, it's much nicer that way. * * @access public * @param string Email * @return VimeoPeopleFindByEmailResponse */ public function findByEmail($sEmail) { $aArgs = array( 'find_email' => $sEmail ); return VimeoBase::executeRemoteCall('vimeo.people.findByEmail', $aArgs); } /** * Get a portrait URL for a given user/size * * Portraits are square, so you only need to pass one size parameter. * Possible sizes are 20, 24, 28, 30, 40, 50, 60, 75, 100, 140, 278 and 300 * * @access public * @param string The username to lookup * @param integer The size of the portrait you you want. (defaults to 75) * @return VimeoPeopleGetPortraitUrlResponse * * @todo Check functionality. Did not work, god knows why */ public function getPortraitUrl($sUser, $iSize = false) { $aArgs = array( 'user' => $sUser ); if($iSize) { $aArgs['size'] = $iSize; } return VimeoBase::executeRemoteCall('vimeo.people.getPortraitUrl', $aArgs); } /** * Add a user as a contact for the authenticated user. * * If Jim is authenticated, and the $user is sally. Sally will be Jim's contact. * It won't work the other way around. Depending on Sally's settings, this may * send her an email notifying her that Jim Added her as a contact. * * @access public * @param string The user to add. User ID, this can be the ID number (151542) or the username (ted) * @return VimeoPeopleAddContactResponse */ public function addContact($sUser) { $aArgs = array( 'user' => $sUser ); return VimeoBase::executeRemoteCall('vimeo.people.addContact', $aArgs); } /** * Remove a user as a contact for the authenticated user. * * @access public * @param string The user to remove. User ID, this can be the ID number (151542) or the username (ted) * @return VimeoPeopleRemoveContactResponse */ public function removeContact($sUser) { $aArgs = array( 'user' => $sUser ); return VimeoBase::executeRemoteCall('vimeo.people.removeContact', $aArgs); } /** * This tells you how much space the user has remaining for uploads. * * We provide info in bytes and kilobytes. It probably makes sense for you to use kilobytes. * * @access public * @return VimeoPeopleGetUploadStatusResponse */ public function getUploadStatus() { return VimeoBase::executeRemoteCall('vimeo.people.getUploadStatus'); } /** * Subscribe to a user's videos. * * Just like on the site, you can subscribe to videos a user "appears" in or "likes." Or both! * This will not remove any subscriptions. So if the user is subscribed to a user for both "likes" * and "appears," this will not change anything if you only specify one of them. If you want to * remove one, you must call vimeo.people.removeSubscription(). * * @access public * @param string User ID, this can be the ID number (151542) or the username (ted) * @param string with self::TYPE_LIKES or self::TYPE_APPEARS or self::TYPE_BOTH * @return VimeoPeopleAddSubscriptionResponse */ public function addSubscription($sUser, $eType = self::TYPE_BOTH) { $aArgs = array( 'user' => $sUser, 'type' => $eType ); return VimeoBase::executeRemoteCall('vimeo.people.addSubscription', $aArgs); } /** * Unsubscribe to a user's videos. * * @access public * @param string User ID, this can be the ID number (151542) or the username (ted) * @param string with self::TYPE_LIKES or self::TYPE_APPEARS or self::TYPE_BOTH * @return VimeoPeopleRemoveSubscriptionResponse */ public function removeSubscription($sUser, $eType = self::TYPE_BOTH) { $aArgs = array( 'user' => $sUser, 'type' => $eType ); return VimeoBase::executeRemoteCall('vimeo.people.removeSubscription', $aArgs); } } /** * Vimeo People FindByUserName response handler class * * Handles the API response for vimeo.people.findByUserName queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleFindByUserNameResponse extends VimeoResponse { private $oUser = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { parent::__construct($aResponse); $this->oUser = new VimeoUserEntity($aResponse->user); } /** * Get user entity object * * @access public * @return VimeoUserEntity */ public function getUser() { return $this->oUser; } } /** * Vimeo People FindByUserName exception handler class * * Handles exceptions caused by API response for vimeo.people.findByUserName queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleFindByUserNameException extends VimeoException {} /** * Vimeo People FindByEmail response handler class * * Handles the API response for vimeo.people.findByEmail queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleFindByEmailResponse extends VimeoResponse { private $oUser = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { parent::__construct($aResponse); $this->oUser = new VimeoUserEntity($aResponse->user); } /** * Get user entity object * * @access public * @return VimeoUserEntity */ public function getUser() { return $this->oUser; } } /** * Vimeo People FindByEmail exception handler class * * Handles exceptions caused by API response for vimeo.people.findByEmail queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleFindByEmailException extends VimeoException {} /** * Vimeo People GetInfo response handler class * * Handles the API response for vimeo.people.getInfo queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleGetInfoResponse extends VimeoResponse { private $oUser = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { parent::__construct($aResponse); $this->oUser = new VimeoUserEntity($aResponse->person); } /** * Get user entity object * * @access public * @return VimeoUserEntity */ public function getUser() { return $this->oUser; } } /** * Vimeo People GetInfo exception handler class * * Handles exceptions caused by API response for vimeo.people.getInfo queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleGetInfoException extends VimeoException {} /** * Vimeo People getPortraitUrl response handler class * * Handles the API response for vimeo.people.getPortraitUrl queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleGetPortraitUrlResponse extends VimeoResponse {} /** * Vimeo People getPortraitUrl exception handler class * * Handles exceptions caused by API response for vimeo.people.getPortraitUrl queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleGetPortraitUrlException extends VimeoException {} /** * Vimeo People addContact response handler class * * Handles the API response for vimeo.people.addContact queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleAddContactResponse extends VimeoResponse {} /** * Vimeo People addContact exception handler class * * Handles exceptions caused by API response for vimeo.people.addContact queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleAddContactException extends VimeoException {} /** * Vimeo People removeContact response handler class * * Handles the API response for vimeo.people.removeContact queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleRemoveContactResponse extends VimeoResponse {} /** * Vimeo People removeContact exception handler class * * Handles exceptions caused by API response for vimeo.people.removeContact queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleRemoveContactException extends VimeoException {} /** * Vimeo People getUploadStatus response handler class * * Handles the API response for vimeo.people.getUploadStatus queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleGetUploadStatusResponse extends VimeoResponse { private $iMaxBytes = false; private $iMaxKBytes = false; private $iUsedBytes = false; private $iUsedKBytes = false; private $iRemainingBytes = false; private $iRemainingKBytes = false; /** * Constructor * * Parses the API response * * @access public * @param stdClass API response * @return void */ public function __construct($aResponse = false) { parent::__construct($aResponse); $this->iMaxBytes = $aResponse->user->bandwidth->maxbytes; $this->iMaxKBytes = $aResponse->user->bandwidth->maxkb; $this->iUsedBytes = $aResponse->user->bandwidth->usedbytes; $this->iUsedKBytes = $aResponse->user->bandwidth->usedkb; $this->iRemainingBytes = $aResponse->user->bandwidth->remainingbytes; $this->iRemainingKBytes = $aResponse->user->bandwidth->remainingkb; } /** * Get maximum upload for this week in BYTES * * @access public * @return integer Maximum bytes this week */ public function getMaxBytes() { return $this->iMaxBytes; } /** * Get maximum upload for this week in KILOBYTES * * @access public * @return integer Maximum kbytes this week */ public function getMaxKiloBytes() { return $this->iMaxKBytes; } /** * Get used upload for this week in BYTES * * @access public * @return integer Used bytes this week */ public function getUsedBytes() { return $this->iUsedBytes; } /** * Get used upload for this week in KILOBYTES * * @access public * @return integer Used kbytes this week */ public function getUsedKiloBytes() { return $this->iUsedKBytes; } /** * Get remaining upload for this week in BYTES * * @access public * @return integer Remaining bytes this week */ public function getRemainingBytes() { return $this->iRemainingBytes; } /** * Get remaining upload for this week in KILOBYTES * * @access public * @return integer Remaining kbytes this week */ public function getRemainingKiloBytes() { return $this->iRemainingKBytes; } } /** * Vimeo People getUploadStatus exception handler class * * Handles exceptions caused by API response for vimeo.people.getUploadStatus queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleGetUploadStatusException extends VimeoException {} /** * Vimeo People addSubscription response handler class * * Handles the API response for vimeo.people.addSubscription queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleAddSubscriptionResponse extends VimeoResponse {} /** * Vimeo People addSubscription exception handler class * * Handles exceptions caused by API response for vimeo.people.addSubscription queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleAddSubscriptionException extends VimeoException {} /** * Vimeo People removeSubscription response handler class * * Handles the API response for vimeo.people.removeSubscription queries. * * @package SimpleVimeo * @subpackage ApiResponse */ class VimeoPeopleRemoveSubscriptionResponse extends VimeoResponse {} /** * Vimeo People removeSubscription exception handler class * * Handles exceptions caused by API response for vimeo.people.removeSubscription queries. * * @package SimpleVimeo * @subpackage Exceptions */ class VimeoPeopleRemoveSubscriptionException extends VimeoException {} ?>