C:/xampp/htdocs/moodle/lib/zend/Zend/Service/Technorati.php

Go to the documentation of this file.

<?php

class Zend_Service_Technorati
{
    const API_URI_BASE = 'http://api.technorati.com';

    const API_PATH_COSMOS           = '/cosmos';
    const API_PATH_SEARCH           = '/search';
    const API_PATH_TAG              = '/tag';
    const API_PATH_DAILYCOUNTS      = '/dailycounts';
    const API_PATH_TOPTAGS          = '/toptags';
    const API_PATH_BLOGINFO         = '/bloginfo';
    const API_PATH_BLOGPOSTTAGS     = '/blogposttags';
    const API_PATH_GETINFO          = '/getinfo';
    const API_PATH_KEYINFO          = '/keyinfo';

    const PARAM_LIMIT_MIN_VALUE = 1;
    const PARAM_LIMIT_MAX_VALUE = 100;
    const PARAM_DAYS_MIN_VALUE  = 1;
    const PARAM_DAYS_MAX_VALUE  = 180;
    const PARAM_START_MIN_VALUE = 1;


    protected $_apiKey;

    protected $_restClient;


    public function __construct($apiKey)
    {
        iconv_set_encoding('output_encoding', 'UTF-8');
        iconv_set_encoding('input_encoding', 'UTF-8');
        iconv_set_encoding('internal_encoding', 'UTF-8');

        $this->_apiKey = $apiKey;
    }


    public function cosmos($url, $options = null)
    {
        static $defaultOptions = array( 'type'      => 'link',
                                        'start'     => 1,
                                        'limit'     => 20,
                                        'current'   => 'yes',
                                        'format'    => 'xml',
                                        'claim'     => 0,
                                        'highlight' => 1,
                                        );

        $options['url'] = $url;

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateCosmos($options);
        $response = $this->_makeRequest(self::API_PATH_COSMOS, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/CosmosResultSet.php';
        return new Zend_Service_Technorati_CosmosResultSet($dom, $options);
    }

    public function search($query, $options = null)
    {
        static $defaultOptions = array( 'start'     => 1,
                                        'limit'     => 20,
                                        'format'    => 'xml',
                                        'claim'     => 0);

        $options['query'] = $query;

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateSearch($options);
        $response = $this->_makeRequest(self::API_PATH_SEARCH, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/SearchResultSet.php';
        return new Zend_Service_Technorati_SearchResultSet($dom, $options);
    }

    public function tag($tag, $options = null)
    {
        static $defaultOptions = array( 'start'          => 1,
                                        'limit'          => 20,
                                        'format'         => 'xml',
                                        'excerptsize'    => 100,
                                        'topexcerptsize' => 150);

        $options['tag'] = $tag;

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateTag($options);
        $response = $this->_makeRequest(self::API_PATH_TAG, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/TagResultSet.php';
        return new Zend_Service_Technorati_TagResultSet($dom, $options);
    }

    public function dailyCounts($query, $options = null)
    {
        static $defaultOptions = array( 'days'      => 180,
                                        'format'    => 'xml'
                                        );

        $options['q'] = $query;

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateDailyCounts($options);
        $response = $this->_makeRequest(self::API_PATH_DAILYCOUNTS, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/DailyCountsResultSet.php';
        return new Zend_Service_Technorati_DailyCountsResultSet($dom);
    }

    public function topTags($options = null)
    {
        static $defaultOptions = array( 'start'     => 1,
                                        'limit'     => 20,
                                        'format'    => 'xml'
                                        );

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateTopTags($options);
        $response = $this->_makeRequest(self::API_PATH_TOPTAGS, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/TagsResultSet.php';
        return new Zend_Service_Technorati_TagsResultSet($dom);
    }

    public function blogInfo($url, $options = null)
    {
        static $defaultOptions = array( 'format'    => 'xml'
                                        );

        $options['url'] = $url;

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateBlogInfo($options);
        $response = $this->_makeRequest(self::API_PATH_BLOGINFO, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/BlogInfoResult.php';
        return new Zend_Service_Technorati_BlogInfoResult($dom);
    }

    public function blogPostTags($url, $options = null)
    {
        static $defaultOptions = array( 'start'     => 1,
                                        'limit'     => 20,
                                        'format'    => 'xml'
                                        );

        $options['url'] = $url;

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateBlogPostTags($options);
        $response = $this->_makeRequest(self::API_PATH_BLOGPOSTTAGS, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/TagsResultSet.php';
        return new Zend_Service_Technorati_TagsResultSet($dom);
    }

    public function getInfo($username, $options = null)
    {
        static $defaultOptions = array('format' => 'xml');

        $options['username'] = $username;

        $options = $this->_prepareOptions($options, $defaultOptions);
        $this->_validateGetInfo($options);
        $response = $this->_makeRequest(self::API_PATH_GETINFO, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/GetInfoResult.php';
        return new Zend_Service_Technorati_GetInfoResult($dom);
    }

    public function keyInfo()
    {
        static $defaultOptions = array();

        $options = $this->_prepareOptions(array(), $defaultOptions);
        // you don't need to validate this request
        // because key is the only mandatory element
        // and it's already set in #_prepareOptions
        $response = $this->_makeRequest(self::API_PATH_KEYINFO, $options);
        $dom = $this->_convertResponseAndCheckContent($response);

        require_once 'Zend/Service/Technorati/KeyInfoResult.php';
        return new Zend_Service_Technorati_KeyInfoResult($dom, $this->_apiKey);
    }


    public function getApiKey()
    {
        return $this->_apiKey;
    }

    public function getRestClient()
    {
        if ($this->_restClient === null) {
            require_once 'Zend/Rest/Client.php';
            $this->_restClient = new Zend_Rest_Client(self::API_URI_BASE);
        }

        return $this->_restClient;
    }

    public function setApiKey($key)
    {
        $this->_apiKey = $key;
        return $this;
    }


    protected function _validateCosmos(array $options)
    {
        static $validOptions = array('key', 'url',
            'type', 'limit', 'start', 'current', 'claim', 'highlight', 'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate url (required)
        $this->_validateOptionUrl($options);
        // Validate limit (optional)
        $this->_validateOptionLimit($options);
        // Validate start (optional)
        $this->_validateOptionStart($options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
        // Validate type (optional)
        $this->_validateInArrayOption('type', $options, array('link', 'weblog'));
        // Validate claim (optional)
        $this->_validateOptionClaim($options);
        // Validate highlight (optional)
        $this->_validateIntegerOption('highlight', $options);
        // Validate current (optional)
        if (isset($options['current'])) {
            $tmp = (int) $options['current'];
            $options['current'] = $tmp ? 'yes' : 'no';
        }

    }

    protected function _validateSearch(array $options)
    {
        static $validOptions = array('key', 'query',
            'language', 'authority', 'limit', 'start', 'claim', 'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate query (required)
        $this->_validateMandatoryOption('query', $options);
        // Validate authority (optional)
        $this->_validateInArrayOption('authority', $options, array('n', 'a1', 'a4', 'a7'));
        // Validate limit (optional)
        $this->_validateOptionLimit($options);
        // Validate start (optional)
        $this->_validateOptionStart($options);
        // Validate claim (optional)
        $this->_validateOptionClaim($options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
    }

    protected function _validateTag(array $options)
    {
        static $validOptions = array('key', 'tag',
            'limit', 'start', 'excerptsize', 'topexcerptsize', 'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate query (required)
        $this->_validateMandatoryOption('tag', $options);
        // Validate limit (optional)
        $this->_validateOptionLimit($options);
        // Validate start (optional)
        $this->_validateOptionStart($options);
        // Validate excerptsize (optional)
        $this->_validateIntegerOption('excerptsize', $options);
        // Validate excerptsize (optional)
        $this->_validateIntegerOption('topexcerptsize', $options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
    }


    protected function _validateDailyCounts(array $options)
    {
        static $validOptions = array('key', 'q',
            'days', 'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate q (required)
        $this->_validateMandatoryOption('q', $options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
        // Validate days (optional)
        if (isset($options['days'])) {
            $options['days'] = (int) $options['days'];
            if ($options['days'] < self::PARAM_DAYS_MIN_VALUE ||
                $options['days'] > self::PARAM_DAYS_MAX_VALUE) {
                require_once 'Zend/Service/Technorati/Exception.php';
                throw new Zend_Service_Technorati_Exception(
                            "Invalid value '" . $options['days'] . "' for 'days' option");
            }
        }
    }

    protected function _validateGetInfo(array $options)
    {
        static $validOptions = array('key', 'username',
            'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate username (required)
        $this->_validateMandatoryOption('username', $options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
    }

    protected function _validateTopTags(array $options)
    {
        static $validOptions = array('key',
            'limit', 'start', 'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate limit (optional)
        $this->_validateOptionLimit($options);
        // Validate start (optional)
        $this->_validateOptionStart($options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
    }

    protected function _validateBlogInfo(array $options)
    {
        static $validOptions = array('key', 'url',
            'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate url (required)
        $this->_validateOptionUrl($options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
    }

    protected function _validateBlogPostTags(array $options)
    {
        static $validOptions = array('key', 'url',
            'limit', 'start', 'format');

        // Validate keys in the $options array
        $this->_compareOptions($options, $validOptions);
        // Validate url (required)
        $this->_validateOptionUrl($options);
        // Validate limit (optional)
        $this->_validateOptionLimit($options);
        // Validate start (optional)
        $this->_validateOptionStart($options);
        // Validate format (optional)
        $this->_validateOptionFormat($options);
    }

    protected function _validateInArrayOption($name, $options, array $array)
    {
        if (isset($options[$name]) && !in_array($options[$name], $array)) {
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception(
                        "Invalid value '{$options[$name]}' for '$name' option");
        }
    }

    protected function _validateMandatoryOption($name, $options)
    {
        if (!isset($options[$name]) || !trim($options[$name])) {
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception(
                        "Empty value for '$name' option");
        }
    }

    protected function _validateIntegerOption($name, $options)
    {
        if (isset($options[$name])) {
            $options[$name] = (int) $options[$name];
        }
    }

    protected function _makeRequest($path, $options = array())
    {
        $restClient = $this->getRestClient();
        $restClient->getHttpClient()->resetParameters();
        $response = $restClient->restGet($path, $options);
        self::_checkResponse($response);
        return $response;
    }

    protected function _validateOptionClaim(array $options)
    {
        $this->_validateIntegerOption('claim', $options);
    }

    protected function _validateOptionFormat(array $options)
    {
        if (isset($options['format']) && $options['format'] != 'xml') {
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception(
                        "Invalid value '" . $options['format'] . "' for 'format' option. " .
                        "Zend_Service_Technorati supports only 'xml'");
        }
    }

    protected function _validateOptionLimit(array $options)
    {
        if (!isset($options['limit'])) return;

        $options['limit'] = (int) $options['limit'];
        if ($options['limit'] < self::PARAM_LIMIT_MIN_VALUE ||
            $options['limit'] > self::PARAM_LIMIT_MAX_VALUE) {
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception(
                        "Invalid value '" . $options['limit'] . "' for 'limit' option");
        }
    }

    protected function _validateOptionStart(array $options)
    {
        if (!isset($options['start'])) return;

        $options['start'] = (int) $options['start'];
        if ($options['start'] < self::PARAM_START_MIN_VALUE) {
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception(
                        "Invalid value '" . $options['start'] . "' for 'start' option");
        }
    }

    protected function _validateOptionUrl(array $options)
    {
        $this->_validateMandatoryOption('url', $options);
    }

    protected static function _checkErrors(DomDocument $dom)
    {
        $xpath = new DOMXPath($dom);

        $result = $xpath->query("/tapi/document/result/error");
        if ($result->length >= 1) {
            $error = $result->item(0)->nodeValue;
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception($error);
        }
    }

    protected function _convertResponseAndCheckContent(Zend_Http_Response $response)
    {
        $dom = new DOMDocument();
        $dom->loadXML($response->getBody());
        self::_checkErrors($dom);
        return $dom;
    }

    protected static function _checkResponse(Zend_Http_Response $response)
    {
        if ($response->isError()) {
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception(sprintf(
                        'Invalid response status code (HTTP/%s %s %s)',
                        $response->getVersion(), $response->getStatus(), $response->getMessage()));
        }
    }

    protected function _compareOptions(array $options, array $validOptions)
    {
        $difference = array_diff(array_keys($options), $validOptions);
        if ($difference) {
            require_once 'Zend/Service/Technorati/Exception.php';
            throw new Zend_Service_Technorati_Exception(
                        "The following parameters are invalid: '" .
                        implode("', '", $difference) . "'");
        }
    }

    protected function _prepareOptions($options, array $defaultOptions)
    {
        $options = (array) $options; // force cast to convert null to array()
        $options['key'] = $this->_apiKey;
        $options = array_merge($defaultOptions, $options);
        return $options;
    }
}