<?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Gdata
* @subpackage App
* @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id$
*/
/**
* Zend_Gdata_Feed
*/
require_once 'Zend/Gdata/App/Feed.php';
/**
* Zend_Gdata_Http_Client
*/
require_once 'Zend/Http/Client.php';
/**
* Zend_Version
*/
require_once 'Zend/Version.php';
/**
* Zend_Gdata_App_MediaSource
*/
require_once 'Zend/Gdata/App/MediaSource.php';
/**
* Zend_Uri/Http
*/
require_once 'Zend/Uri/Http.php';
/** @see Zend_Xml_Security */
require_once 'Zend/Xml/Security.php';
/**
* Provides Atom Publishing Protocol (APP) functionality. This class and all
* other components of Zend_Gdata_App are designed to work independently from
* other Zend_Gdata components in order to interact with generic APP services.
*
* @category Zend
* @package Zend_Gdata
* @subpackage App
* @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Gdata_App
{
/** Default major protocol version.
*
* @see _majorProtocolVersion
*/
const DEFAULT_MAJOR_PROTOCOL_VERSION = 1;
/** Default minor protocol version.
*
* @see _minorProtocolVersion
*/
const DEFAULT_MINOR_PROTOCOL_VERSION = null;
/**
* Client object used to communicate
*
* @var Zend_Http_Client
*/
protected $_httpClient;
/**
* Client object used to communicate in static context
*
* @var Zend_Http_Client
*/
protected static $_staticHttpClient = null;
/**
* Override HTTP PUT and DELETE request methods?
*
* @var boolean
*/
protected static $_httpMethodOverride = false;
/**
* Enable gzipped responses?
*
* @var boolean
*/
protected static $_gzipEnabled = false;
/**
* Use verbose exception messages. In the case of HTTP errors,
* use the body of the HTTP response in the exception message.
*
* @var boolean
*/
protected static $_verboseExceptionMessages = true;
/**
* Default URI to which to POST.
*
* @var string
*/
protected $_defaultPostUri = null;
/**
* Packages to search for classes when using magic __call method, in order.
*
* @var array
*/
protected $_registeredPackages = array(
'Zend_Gdata_App_Extension',
'Zend_Gdata_App');
/**
* Maximum number of redirects to follow during HTTP operations
*
* @var int
*/
protected static $_maxRedirects = 5;
/**
* Indicates the major protocol version that should be used.
* At present, recognized values are either 1 or 2. However, any integer
* value >= 1 is considered valid.
*
* Under most circumtances, this will be automatically set by
* Zend_Gdata_App subclasses.
*
* @see setMajorProtocolVersion()
* @see getMajorProtocolVersion()
*/
protected $_majorProtocolVersion;
/**
* Indicates the minor protocol version that should be used. Can be set
* to either an integer >= 0, or NULL if no minor version should be sent
* to the server.
*
* At present, this field is not used by any Google services, but may be
* used in the future.
*
* Under most circumtances, this will be automatically set by
* Zend_Gdata_App subclasses.
*
* @see setMinorProtocolVersion()
* @see getMinorProtocolVersion()
*/
protected $_minorProtocolVersion;
/**
* Whether we want to use XML to object mapping when fetching data.
*
* @var boolean
*/
protected $_useObjectMapping = true;
/**
* Create Gdata object
*
* @param Zend_Http_Client $client
* @param string $applicationId
*/
public function __construct($client = null, $applicationId = 'MyCompany-MyApp-1.0')
{
$this->setHttpClient($client, $applicationId);
// Set default protocol version. Subclasses should override this as
// needed once a given service supports a new version.
$this->setMajorProtocolVersion(self::DEFAULT_MAJOR_PROTOCOL_VERSION);
$this->setMinorProtocolVersion(self::DEFAULT_MINOR_PROTOCOL_VERSION);
}
/**
* Adds a Zend Framework package to the $_registeredPackages array.
* This array is searched when using the magic __call method below
* to instantiante new objects.
*
* @param string $name The name of the package (eg Zend_Gdata_App)
* @return void
*/
public function registerPackage($name)
{
array_unshift($this->_registeredPackages, $name);
}
/**
* Retrieve feed as string or object
*
* @param string $uri The uri from which to retrieve the feed
* @param string $className The class which is used as the return type
* @return string|Zend_Gdata_App_Feed Returns string only if the object
* mapping has been disabled explicitly
* by passing false to the
* useObjectMapping() function.
*/
public function getFeed($uri, $className='Zend_Gdata_App_Feed')
{
return $this->importUrl($uri, $className, null);
}
/**
* Retrieve entry as string or object
*
* @param string $uri
* @param string $className The class which is used as the return type
* @return string|Zend_Gdata_App_Entry Returns string only if the object
* mapping has been disabled explicitly
* by passing false to the
* useObjectMapping() function.
*/
public function getEntry($uri, $className='Zend_Gdata_App_Entry')
{
return $this->importUrl($uri, $className, null);
}
/**
* Get the Zend_Http_Client object used for communication
*
* @return Zend_Http_Client
*/
public function getHttpClient()
{
return $this->_httpClient;
}
/**
* Set the Zend_Http_Client object used for communication
*
* @param Zend_Http_Client $client The client to use for communication
* @throws Zend_Gdata_App_HttpException
* @return Zend_Gdata_App Provides a fluent interface
*/
public function setHttpClient($client,
$applicationId = 'MyCompany-MyApp-1.0')
{
if ($client === null) {
$client = new Zend_Http_Client();
}
if (!$client instanceof Zend_Http_Client) {
require_once 'Zend/Gdata/App/HttpException.php';
throw new Zend_Gdata_App_HttpException(
'Argument is not an instance of Zend_Http_Client.');
}
$userAgent = $applicationId . ' Zend_Framework_Gdata/' .
Zend_Version::VERSION;
$client->setHeaders('User-Agent', $userAgent);
$client->setConfig(array(
'strictredirects' => true
)
);
$this->_httpClient = $client;
self::setStaticHttpClient($client);
return $this;
}
/**
* Set the static HTTP client instance
*
* Sets the static HTTP client object to use for retrieving the feed.
*
* @param Zend_Http_Client $httpClient
* @return void
*/
public static function setStaticHttpClient(Zend_Http_Client $httpClient)
{
self::$_staticHttpClient = $httpClient;
}
/**
* Gets the HTTP client object. If none is set, a new Zend_Http_Client will be used.
*
* @return Zend_Http_Client
*/
public static function getStaticHttpClient()
{
if (!self::$_staticHttpClient instanceof Zend_Http_Client) {
$client = new Zend_Http_Client();
$userAgent = 'Zend_Framework_Gdata/' . Zend_Version::VERSION;
$client->setHeaders('User-Agent', $userAgent);
$client->setConfig(array(
'strictredirects' => true
)
);
self::$_staticHttpClient = $client;
}
return self::$_staticHttpClient;
}
/**
* Toggle using POST instead of PUT and DELETE HTTP methods
*
* Some feed implementations do not accept PUT and DELETE HTTP
* methods, or they can't be used because of proxies or other
* measures. This allows turning on using POST where PUT and
* DELETE would normally be used; in addition, an
* X-Method-Override header will be sent with a value of PUT or
* DELETE as appropriate.
*
* @param boolean $override Whether to override PUT and DELETE with POST.
* @return void
*/
public static function setHttpMethodOverride($override = true)
{
self::$_httpMethodOverride = $override;
}
/**
* Get the HTTP override state
*
* @return boolean
*/
public static function getHttpMethodOverride()
{
return self::$_httpMethodOverride;
}
/**
* Toggle requesting gzip encoded responses
*
* @param boolean $enabled Whether or not to enable gzipped responses
* @return void
*/
public static function setGzipEnabled($enabled = false)
{
if ($enabled && !function_exists('gzinflate')) {
require_once 'Zend/Gdata/App/InvalidArgumentException.php';
throw new Zend_Gdata_App_InvalidArgumentException(
'You cannot enable gzipped responses if the zlib module ' .
'is not enabled in your PHP installation.');
}
self::$_gzipEnabled = $enabled;
}
/**
* Get the HTTP override state
*
* @return boolean
*/
public static function getGzipEnabled()
{
return self::$_gzipEnabled;
}
/**
* Get whether to use verbose exception messages
*
* In the case of HTTP errors, use the body of the HTTP response
* in the exception message.
*
* @return boolean
*/
public static function getVerboseExceptionMessages()
{
return self::$_verboseExceptionMessages;
}
/**
* Set whether to use verbose exception messages
*
* In the case of HTTP errors, use the body of the HTTP response
* in the exception message.
*
* @param boolean $verbose Whether to use verbose exception messages
*/
public static function setVerboseExceptionMessages($verbose)
{
self::$_verboseExceptionMessages = $verbose;
}
/**
* Set the maximum number of redirects to follow during HTTP operations
*
* @param int $maxRedirects Maximum number of redirects to follow
* @return void
*/
public static function setMaxRedirects($maxRedirects)
{
self::$_maxRedirects = $maxRedirects;
}
/**
* Get the maximum number of redirects to follow during HTTP operations
*
* @return int Maximum number of redirects to follow
*/
public static function getMaxRedirects()
{
return self::$_maxRedirects;
}
/**
* Set the major protocol version that should be used. Values < 1 will
* cause a Zend_Gdata_App_InvalidArgumentException to be thrown.
*
* @see _majorProtocolVersion
* @param int $value The major protocol version to use.
* @throws Zend_Gdata_App_InvalidArgumentException
*/
public function setMajorProtocolVersion($value)
{
if (!($value >= 1)) {
require_once('Zend/Gdata/App/InvalidArgumentException.php');
throw new Zend_Gdata_App_InvalidArgumentException(
'Major protocol version must be >= 1');
}
$this->_majorProtocolVersion = $value;
}
/**
* Get the major protocol version that is in use.
*
* @see _majorProtocolVersion
* @return int The major protocol version in use.
*/
public function getMajorProtocolVersion()
{
return $this->_majorProtocolVersion;
}
/**
* Set the minor protocol version that should be used. If set to NULL, no
* minor protocol version will be sent to the server. Values < 0 will
* cause a Zend_Gdata_App_InvalidArgumentException to be thrown.
*
* @see _minorProtocolVersion
* @param (int|NULL) $value The minor protocol version to use.
* @throws Zend_Gdata_App_InvalidArgumentException
*/
public function setMinorProtocolVersion($value)
{
if (!($value >= 0)) {
require_once('Zend/Gdata/App/InvalidArgumentException.php');
throw new Zend_Gdata_App_InvalidArgumentException(
'Minor protocol version must be >= 0');
}
$this->_minorProtocolVersion = $value;
}
/**
* Get the minor protocol version that is in use.
*
* @see _minorProtocolVersion
* @return (int|NULL) The major protocol version in use, or NULL if no
* minor version is specified.
*/
public function getMinorProtocolVersion()
{
return $this->_minorProtocolVersion;
}
/**
* Provides pre-processing for HTTP requests to APP services.
*
* 1. Checks the $data element and, if it's an entry, extracts the XML,
* multipart data, edit link (PUT,DELETE), etc.
* 2. If $data is a string, sets the default content-type header as
* 'application/atom+xml' if it's not already been set.
* 3. Adds a x-http-method override header and changes the HTTP method
* to 'POST' if necessary as per getHttpMethodOverride()
*
* @param string $method The HTTP method for the request - 'GET', 'POST',
* 'PUT', 'DELETE'
* @param string $url The URL to which this request is being performed,
* or null if found in $data
* @param array $headers An associative array of HTTP headers for this
* request
* @param mixed $data The Zend_Gdata_App_Entry or XML for the
* body of the request
* @param string $contentTypeOverride The override value for the
* content type of the request body
* @return array An associative array containing the determined
* 'method', 'url', 'data', 'headers', 'contentType'
*/
public function prepareRequest($method,
$url = null,
$headers = array(),
$data = null,
$contentTypeOverride = null)
{
// As a convenience, if $headers is null, we'll convert it back to
// an empty array.
if ($headers === null) {
$headers = array();
}
$rawData = null;
$finalContentType = null;
if ($url == null) {
$url = $this->_defaultPostUri;
}
if (is_string($data)) {
$rawData = $data;
if ($contentTypeOverride === null) {
$finalContentType = 'application/atom+xml';
}
} elseif ($data instanceof Zend_Gdata_App_MediaEntry) {
$rawData = $data->encode();
if ($data->getMediaSource() !== null) {
$finalContentType = $rawData->getContentType();
$headers['MIME-version'] = '1.0';
$headers['Slug'] = $data->getMediaSource()->getSlug();
} else {
$finalContentType = 'application/atom+xml';
}
if ($method == 'PUT' || $method == 'DELETE') {
$editLink = $data->getEditLink();
if ($editLink != null && $url == null) {
$url = $editLink->getHref();
}
}
} elseif ($data instanceof Zend_Gdata_App_Entry) {
$rawData = $data->saveXML();
$finalContentType = 'application/atom+xml';
if ($method == 'PUT' || $method == 'DELETE') {
$editLink = $data->getEditLink();
if ($editLink != null) {
$url = $editLink->getHref();
}
}
} elseif ($data instanceof Zend_Gdata_App_MediaSource) {
$rawData = $data->encode();
if ($data->getSlug() !== null) {
$headers['Slug'] = $data->getSlug();
}
$finalContentType = $data->getContentType();
}
if ($method == 'DELETE') {
$rawData = null;
}
// Set an If-Match header if:
// - This isn't a DELETE
// - If this isn't a GET, the Etag isn't weak
// - A similar header (If-Match/If-None-Match) hasn't already been
// set.
if ($method != 'DELETE' && (
!array_key_exists('If-Match', $headers) &&
!array_key_exists('If-None-Match', $headers)
) ) {
$allowWeak = $method == 'GET';
if ($ifMatchHeader = $this->generateIfMatchHeaderData(
$data, $allowWeak)) {
$headers['If-Match'] = $ifMatchHeader;
}
}
if ($method != 'POST' && $method != 'GET' && Zend_Gdata_App::getHttpMethodOverride()) {
$headers['x-http-method-override'] = $method;
$method = 'POST';
} else {
$headers['x-http-method-override'] = null;
}
if ($contentTypeOverride != null) {
$finalContentType = $contentTypeOverride;
}
return array('method' => $method, 'url' => $url,
'data' => $rawData, 'headers' => $headers,
'contentType' => $finalContentType);
}
/**
* Performs a HTTP request using the specified method
*
* @param string $method The HTTP method for the request - 'GET', 'POST',
* 'PUT', 'DELETE'
* @param string $url The URL to which this request is being performed
* @param array $headers An associative array of HTTP headers
* for this request
* @param string $body The body of the HTTP request
* @param string $contentType The value for the content type
* of the request body
* @param int $remainingRedirects Number of redirects to follow if request
* s results in one
* @return Zend_Http_Response The response object
*/
public function performHttpRequest($method, $url, $headers = null,
$body = null, $contentType = null, $remainingRedirects = null)
{
require_once 'Zend/Http/Client/Exception.php';
if ($remainingRedirects === null) {
$remainingRedirects = self::getMaxRedirects();
}
if ($headers === null) {
$headers = array();
}
// Append a Gdata version header if protocol v2 or higher is in use.
// (Protocol v1 does not use this header.)
$major = $this->getMajorProtocolVersion();
$minor = $this->getMinorProtocolVersion();
if ($major >= 2) {
$headers['GData-Version'] = $major +
(($minor === null) ? '.' + $minor : '');
}
// check the overridden method
if (($method == 'POST' || $method == 'PUT') && $body === null &&
$headers['x-http-method-override'] != 'DELETE') {
require_once 'Zend/Gdata/App/InvalidArgumentException.php';
throw new Zend_Gdata_App_InvalidArgumentException(
'You must specify the data to post as either a ' .
'string or a child of Zend_Gdata_App_Entry');
}
if ($url === null) {
require_once 'Zend/Gdata/App/InvalidArgumentException.php';
throw new Zend_Gdata_App_InvalidArgumentException(
'You must specify an URI to which to post.');
}
$headers['Content-Type'] = $contentType;
if (Zend_Gdata_App::getGzipEnabled()) {
// some services require the word 'gzip' to be in the user-agent
// header in addition to the accept-encoding header
if (strpos($this->_httpClient->getHeader('User-Agent'),
'gzip') === false) {
$headers['User-Agent'] =
$this->_httpClient->getHeader('User-Agent') . ' (gzip)';
}
$headers['Accept-encoding'] = 'gzip, deflate';
} else {
$headers['Accept-encoding'] = 'identity';
}
// Make sure the HTTP client object is 'clean' before making a request
// In addition to standard headers to reset via resetParameters(),
// also reset the Slug and If-Match headers
$this->_httpClient->resetParameters();
$this->_httpClient->setHeaders(array('Slug', 'If-Match'));
// Set the params for the new request to be performed
$this->_httpClient->setHeaders($headers);
require_once 'Zend/Uri/Http.php';
$uri = Zend_Uri_Http::fromString($url);
preg_match("/^(.*?)(\?.*)?$/", $url, $matches);
$this->_httpClient->setUri($matches[1]);
$queryArray = $uri->getQueryAsArray();
foreach ($queryArray as $name => $value) {
$this->_httpClient->setParameterGet($name, $value);
}
$this->_httpClient->setConfig(array('maxredirects' => 0));
// Set the proper adapter if we are handling a streaming upload
$usingMimeStream = false;
$oldHttpAdapter = null;
if ($body instanceof Zend_Gdata_MediaMimeStream) {
$usingMimeStream = true;
$this->_httpClient->setRawDataStream($body, $contentType);
$oldHttpAdapter = $this->_httpClient->getAdapter();
if ($oldHttpAdapter instanceof Zend_Http_Client_Adapter_Proxy) {
require_once 'Zend/Gdata/HttpAdapterStreamingProxy.php';
$newAdapter = new Zend_Gdata_HttpAdapterStreamingProxy();
} else {
require_once 'Zend/Gdata/HttpAdapterStreamingSocket.php';
$newAdapter = new Zend_Gdata_HttpAdapterStreamingSocket();
}
$this->_httpClient->setAdapter($newAdapter);
} else {
$this->_httpClient->setRawData($body, $contentType);
}
try {
$response = $this->_httpClient->request($method);
// reset adapter
if ($usingMimeStream) {
$this->_httpClient->setAdapter($oldHttpAdapter);
}
} catch (Zend_Http_Client_Exception $e) {
// reset adapter
if ($usingMimeStream) {
$this->_httpClient->setAdapter($oldHttpAdapter);
}
require_once 'Zend/Gdata/App/HttpException.php';
throw new Zend_Gdata_App_HttpException($e->getMessage(), $e);
}
if ($response->isRedirect() && $response->getStatus() != '304') {
if ($remainingRedirects > 0) {
$newUrl = $response->getHeader('Location');
$response = $this->performHttpRequest(
$method, $newUrl, $headers, $body,
$contentType, $remainingRedirects);
} else {
require_once 'Zend/Gdata/App/HttpException.php';
throw new Zend_Gdata_App_HttpException(
'Number of redirects exceeds maximum', null, $response);
}
}
if (!$response->isSuccessful()) {
require_once 'Zend/Gdata/App/HttpException.php';
$exceptionMessage = 'Expected response code 200, got ' .
$response->getStatus();
if (self::getVerboseExceptionMessages()) {
$exceptionMessage .= "\n" . $response->getBody();
}
$exception = new Zend_Gdata_App_HttpException($exceptionMessage);
$exception->setResponse($response);
throw $exception;
}
return $response;
}
/**
* Imports a feed located at $uri.
*
* @param string $uri
* @param Zend_Http_Client $client The client used for communication
* @param string $className The class which is used as the return type
* @param bool $useObjectMapping Enable/disable the use of XML to object mapping.
* @throws Zend_Gdata_App_Exception
* @return string|Zend_Gdata_App_Feed Returns string only if the fourth
* parameter ($useObjectMapping) is set
* to false.
*/
public static function import($uri, $client = null,
$className='Zend_Gdata_App_Feed', $useObjectMapping = true)
{
$app = new Zend_Gdata_App($client);
$requestData = $app->prepareRequest('GET', $uri);
$response = $app->performHttpRequest(
$requestData['method'], $requestData['url']);
$feedContent = $response->getBody();
if (false === $useObjectMapping) {
return $feedContent;
}
$feed = self::importString($feedContent, $className);
if ($client != null) {
$feed->setHttpClient($client);
}
return $feed;
}
/**
* Imports the specified URL (non-statically).
*
* @param string $url The URL to import
* @param string $className The class which is used as the return type
* @param array $extraHeaders Extra headers to add to the request, as an
* array of string-based key/value pairs.
* @throws Zend_Gdata_App_Exception
* @return string|Zend_Gdata_App_Feed Returns string only if the object
* mapping has been disabled explicitly
* by passing false to the
* useObjectMapping() function.
*/
public function importUrl($url, $className='Zend_Gdata_App_Feed',
$extraHeaders = array())
{
$response = $this->get($url, $extraHeaders);
$feedContent = $response->getBody();
if (!$this->_useObjectMapping) {
return $feedContent;
}
$protocolVersionStr = $response->getHeader('GData-Version');
$majorProtocolVersion = null;
$minorProtocolVersion = null;
if ($protocolVersionStr !== null) {
// Extract protocol major and minor version from header
$delimiterPos = strpos($protocolVersionStr, '.');
$length = strlen($protocolVersionStr);
$major = substr($protocolVersionStr, 0, $delimiterPos);
$minor = substr($protocolVersionStr, $delimiterPos + 1, $length);
$majorProtocolVersion = $major;
$minorProtocolVersion = $minor;
}
$feed = self::importString($feedContent, $className,
$majorProtocolVersion, $minorProtocolVersion);
if ($this->getHttpClient() != null) {
$feed->setHttpClient($this->getHttpClient());
}
$etag = $response->getHeader('ETag');
if ($etag !== null) {
$feed->setEtag($etag);
}
return $feed;
}
/**
* Imports a feed represented by $string.
*
* @param string $string
* @param string $className The class which is used as the return type
* @param integer $majorProcolVersion (optional) The major protocol version
* of the data model object that is to be created.
* @param integer $minorProcolVersion (optional) The minor protocol version
* of the data model object that is to be created.
* @throws Zend_Gdata_App_Exception
* @return Zend_Gdata_App_Feed
*/
public static function importString($string,
$className='Zend_Gdata_App_Feed', $majorProtocolVersion = null,
$minorProtocolVersion = null)
{
if (!class_exists($className, false)) {
require_once 'Zend/Loader.php';
@Zend_Loader::loadClass($className);
}
// Load the feed as an XML DOMDocument object
@ini_set('track_errors', 1);
$doc = new DOMDocument();
$doc = @Zend_Xml_Security::scan($string, $doc);
@ini_restore('track_errors');
if (!$doc) {
require_once 'Zend/Gdata/App/Exception.php';
throw new Zend_Gdata_App_Exception(
"DOMDocument cannot parse XML: $php_errormsg");
}
$feed = new $className();
$feed->setMajorProtocolVersion($majorProtocolVersion);
$feed->setMinorProtocolVersion($minorProtocolVersion);
$feed->transferFromXML($string);
$feed->setHttpClient(self::getstaticHttpClient());
return $feed;
}
/**
* Imports a feed from a file located at $filename.
*
* @param string $filename
* @param string $className The class which is used as the return type
* @param string $useIncludePath Whether the include_path should be searched
* @throws Zend_Gdata_App_Exception
* @return Zend_Gdata_App_Feed
*/
public static function importFile($filename,
$className='Zend_Gdata_App_Feed', $useIncludePath = false)
{
@ini_set('track_errors', 1);
$feed = @file_get_contents($filename, $useIncludePath);
@ini_restore('track_errors');
if ($feed === false) {
require_once 'Zend/Gdata/App/Exception.php';
throw new Zend_Gdata_App_Exception(
"File could not be loaded: $php_errormsg");
}
return self::importString($feed, $className);
}
/**
* GET a URI using client object.
*
* @param string $uri GET URI
* @param array $extraHeaders Extra headers to add to the request, as an
* array of string-based key/value pairs.
* @throws Zend_Gdata_App_HttpException
* @return Zend_Http_Response
*/
public function get($uri, $extraHeaders = array())
{
$requestData = $this->prepareRequest('GET', $uri, $extraHeaders);
return $this->performHttpRequest(
$requestData['method'], $requestData['url'],
$requestData['headers']);
}
/**
* POST data with client object
*
* @param mixed $data The Zend_Gdata_App_Entry or XML to post
* @param string $uri POST URI
* @param array $headers Additional HTTP headers to insert.
* @param string $contentType Content-type of the data
* @param array $extraHeaders Extra headers to add to the request, as an
* array of string-based key/value pairs.
* @return Zend_Http_Response
* @throws Zend_Gdata_App_Exception
* @throws Zend_Gdata_App_HttpException
* @throws Zend_Gdata_App_InvalidArgumentException
*/
public function post($data, $uri = null, $remainingRedirects = null,
$contentType = null, $extraHeaders = null)
{
$requestData = $this->prepareRequest(
'POST', $uri, $extraHeaders, $data, $contentType);
return $this->performHttpRequest(
$requestData['method'], $requestData['url'],
$requestData['headers'], $requestData['data'],
$requestData['contentType']);
}
/**
* PUT data with client object
*
* @param mixed $data The Zend_Gdata_App_Entry or XML to post
* @param string $uri PUT URI
* @param array $headers Additional HTTP headers to insert.
* @param string $contentType Content-type of the data
* @param array $extraHeaders Extra headers to add to the request, as an
* array of string-based key/value pairs.
* @return Zend_Http_Response
* @throws Zend_Gdata_App_Exception
* @throws Zend_Gdata_App_HttpException
* @throws Zend_Gdata_App_InvalidArgumentException
*/
public function put($data, $uri = null, $remainingRedirects = null,
$contentType = null, $extraHeaders = null)
{
$requestData = $this->prepareRequest(
'PUT', $uri, $extraHeaders, $data, $contentType);
return $this->performHttpRequest(
$requestData['method'], $requestData['url'],
$requestData['headers'], $requestData['data'],
$requestData['contentType']);
}
/**
* DELETE entry with client object
*
* @param mixed $data The Zend_Gdata_App_Entry or URL to delete
* @return void
* @throws Zend_Gdata_App_Exception
* @throws Zend_Gdata_App_HttpException
* @throws Zend_Gdata_App_InvalidArgumentException
*/
public function delete($data, $remainingRedirects = null)
{
if (is_string($data)) {
$requestData = $this->prepareRequest('DELETE', $data);
} else {
$headers = array();
$requestData = $this->prepareRequest(
'DELETE', null, $headers, $data);
}
return $this->performHttpRequest($requestData['method'],
$requestData['url'],
$requestData['headers'],
'',
$requestData['contentType'],
$remainingRedirects);
}
/**
* Inserts an entry to a given URI and returns the response as a
* fully formed Entry.
*
* @param mixed $data The Zend_Gdata_App_Entry or XML to post
* @param string $uri POST URI
* @param string $className The class of entry to be returned.
* @param array $extraHeaders Extra headers to add to the request, as an
* array of string-based key/value pairs.
* @return Zend_Gdata_App_Entry The entry returned by the service after
* insertion.
*/
public function insertEntry($data, $uri, $className='Zend_Gdata_App_Entry',
$extraHeaders = array())
{
if (!class_exists($className, false)) {
require_once 'Zend/Loader.php';
@Zend_Loader::loadClass($className);
}
$response = $this->post($data, $uri, null, null, $extraHeaders);
$returnEntry = new $className($response->getBody());
$returnEntry->setHttpClient(self::getstaticHttpClient());
$etag = $response->getHeader('ETag');
if ($etag !== null) {
$returnEntry->setEtag($etag);
}
return $returnEntry;
}
/**
* Update an entry
*
* @param mixed $data Zend_Gdata_App_Entry or XML (w/ID and link rel='edit')
* @param string|null The URI to send requests to, or null if $data
* contains the URI.
* @param string|null The name of the class that should be deserialized
* from the server response. If null, then 'Zend_Gdata_App_Entry'
* will be used.
* @param array $extraHeaders Extra headers to add to the request, as an
* array of string-based key/value pairs.
* @return Zend_Gdata_App_Entry The entry returned from the server
* @throws Zend_Gdata_App_Exception
*/
public function updateEntry($data, $uri = null, $className = null,
$extraHeaders = array())
{
if ($className === null && $data instanceof Zend_Gdata_App_Entry) {
$className = get_class($data);
} elseif ($className === null) {
$className = 'Zend_Gdata_App_Entry';
}
if (!class_exists($className, false)) {
require_once 'Zend/Loader.php';
@Zend_Loader::loadClass($className);
}
$response = $this->put($data, $uri, null, null, $extraHeaders);
$returnEntry = new $className($response->getBody());
$returnEntry->setHttpClient(self::getstaticHttpClient());
$etag = $response->getHeader('ETag');
if ($etag !== null) {
$returnEntry->setEtag($etag);
}
return $returnEntry;
}
/**
* Provides a magic factory method to instantiate new objects with
* shorter syntax than would otherwise be required by the Zend Framework
* naming conventions. For instance, to construct a new
* Zend_Gdata_Calendar_Extension_Color, a developer simply needs to do
* $gCal->newColor(). For this magic constructor, packages are searched
* in the same order as which they appear in the $_registeredPackages
* array
*
* @param string $method The method name being called
* @param array $args The arguments passed to the call
* @throws Zend_Gdata_App_Exception
*/
public function __call($method, $args)
{
if (preg_match('/^new(\w+)/', $method, $matches)) {
$class = $matches[1];
$foundClassName = null;
foreach ($this->_registeredPackages as $name) {
try {
// Autoloading disabled on next line for compatibility
// with magic factories. See ZF-6660.
if (!class_exists($name . '_' . $class, false)) {
require_once 'Zend/Loader.php';
@Zend_Loader::loadClass($name . '_' . $class);
}
$foundClassName = $name . '_' . $class;
break;
} catch (Zend_Exception $e) {
// package wasn't here- continue searching
} catch (ErrorException $e) {
// package wasn't here- continue searching
// @see ZF-7013 and ZF-11959
}
}
if ($foundClassName != null) {
$reflectionObj = new ReflectionClass($foundClassName);
$instance = $reflectionObj->newInstanceArgs($args);
if ($instance instanceof Zend_Gdata_App_FeedEntryParent) {
$instance->setHttpClient($this->_httpClient);
// Propogate version data
$instance->setMajorProtocolVersion(
$this->_majorProtocolVersion);
$instance->setMinorProtocolVersion(
$this->_minorProtocolVersion);
}
return $instance;
} else {
require_once 'Zend/Gdata/App/Exception.php';
throw new Zend_Gdata_App_Exception(
"Unable to find '${class}' in registered packages");
}
} else {
require_once 'Zend/Gdata/App/Exception.php';
throw new Zend_Gdata_App_Exception("No such method ${method}");
}
}
/**
* Retrieve all entries for a feed, iterating through pages as necessary.
* Be aware that calling this function on a large dataset will take a
* significant amount of time to complete. In some cases this may cause
* execution to timeout without proper precautions in place.
*
* @param object $feed The feed to iterate through.
* @return mixed A new feed of the same type as the one originally
* passed in, containing all relevent entries.
*/
public function retrieveAllEntriesForFeed($feed) {
$feedClass = get_class($feed);
$reflectionObj = new ReflectionClass($feedClass);
$result = $reflectionObj->newInstance();
do {
foreach ($feed as $entry) {
$result->addEntry($entry);
}
$next = $feed->getLink('next');
if ($next !== null) {
$feed = $this->getFeed($next->href, $feedClass);
} else {
$feed = null;
}
}
while ($feed != null);
return $result;
}
/**
* This method enables logging of requests by changing the
* Zend_Http_Client_Adapter used for performing the requests.
* NOTE: This will not work if you have customized the adapter
* already to use a proxy server or other interface.
*
* @param string $logfile The logfile to use when logging the requests
*/
public function enableRequestDebugLogging($logfile)
{
$this->_httpClient->setConfig(array(
'adapter' => 'Zend_Gdata_App_LoggingHttpClientAdapterSocket',
'logfile' => $logfile
));
}
/**
* Retrieve next set of results based on a given feed.
*
* @param Zend_Gdata_App_Feed $feed The feed from which to
* retreive the next set of results.
* @param string $className (optional) The class of feed to be returned.
* If null, the next feed (if found) will be the same class as
* the feed that was given as the first argument.
* @return Zend_Gdata_App_Feed|null Returns a
* Zend_Gdata_App_Feed or null if no next set of results
* exists.
*/
public function getNextFeed($feed, $className = null)
{
$nextLink = $feed->getNextLink();
if (!$nextLink) {
return null;
}
$nextLinkHref = $nextLink->getHref();
if ($className === null) {
$className = get_class($feed);
}
return $this->getFeed($nextLinkHref, $className);
}
/**
* Retrieve previous set of results based on a given feed.
*
* @param Zend_Gdata_App_Feed $feed The feed from which to
* retreive the previous set of results.
* @param string $className (optional) The class of feed to be returned.
* If null, the previous feed (if found) will be the same class as
* the feed that was given as the first argument.
* @return Zend_Gdata_App_Feed|null Returns a
* Zend_Gdata_App_Feed or null if no previous set of results
* exists.
*/
public function getPreviousFeed($feed, $className = null)
{
$previousLink = $feed->getPreviousLink();
if (!$previousLink) {
return null;
}
$previousLinkHref = $previousLink->getHref();
if ($className === null) {
$className = get_class($feed);
}
return $this->getFeed($previousLinkHref, $className);
}
/**
* Returns the data for an If-Match header based on the current Etag
* property. If Etags are not supported by the server or cannot be
* extracted from the data, then null will be returned.
*
* @param boolean $allowWeak If false, then if a weak Etag is detected,
* then return null rather than the Etag.
* @return string|null $data
*/
public function generateIfMatchHeaderData($data, $allowWeek)
{
$result = '';
// Set an If-Match header if an ETag has been set (version >= 2 only)
if ($this->_majorProtocolVersion >= 2 &&
$data instanceof Zend_Gdata_App_Entry) {
$etag = $data->getEtag();
if (($etag !== null) &&
($allowWeek || substr($etag, 0, 2) != 'W/')) {
$result = $data->getEtag();
}
}
return $result;
}
/**
* Determine whether service object is using XML to object mapping.
*
* @return boolean True if service object is using XML to object mapping,
* false otherwise.
*/
public function usingObjectMapping()
{
return $this->_useObjectMapping;
}
/**
* Enable/disable the use of XML to object mapping.
*
* @param boolean $value Pass in true to use the XML to object mapping.
* Pass in false or null to disable it.
* @return void
*/
public function useObjectMapping($value)
{
if ($value === True) {
$this->_useObjectMapping = true;
} else {
$this->_useObjectMapping = false;
}
}
}