[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Zend Framework
   4   *
   5   * LICENSE
   6   *
   7   * This source file is subject to the new BSD license that is bundled
   8   * with this package in the file LICENSE.txt.
   9   * It is also available through the world-wide-web at this URL:
  10   * http://framework.zend.com/license/new-bsd
  11   * If you did not receive a copy of the license and are unable to
  12   * obtain it through the world-wide-web, please send an email
  13   * to [email protected] so we can send you a copy immediately.
  14   *
  15   * @category   Zend
  16   * @package    Zend_Service
  17   * @subpackage Akismet
  18   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  19   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20   * @version    $Id$
  21   */
  22  
  23  
  24  /**
  25   * @see Zend_Version
  26   */
  27  require_once 'Zend/Version.php';
  28  
  29  /**
  30   * @see Zend_Service_Abstract
  31   */
  32  require_once 'Zend/Service/Abstract.php';
  33  
  34  
  35  /**
  36   * Akismet REST service implementation
  37   *
  38   * @uses       Zend_Service_Abstract
  39   * @category   Zend
  40   * @package    Zend_Service
  41   * @subpackage Akismet
  42   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  43   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  44   */
  45  class Zend_Service_Akismet extends Zend_Service_Abstract
  46  {
  47      /**
  48       * Akismet API key
  49       * @var string
  50       */
  51      protected $_apiKey;
  52  
  53      /**
  54       * Blog URL
  55       * @var string
  56       */
  57      protected $_blogUrl;
  58  
  59      /**
  60       * Charset used for encoding
  61       * @var string
  62       */
  63      protected $_charset = 'UTF-8';
  64  
  65      /**
  66       * TCP/IP port to use in requests
  67       * @var int
  68       */
  69      protected $_port = 80;
  70  
  71      /**
  72       * User Agent string to send in requests
  73       * @var string
  74       */
  75      protected $_userAgent;
  76  
  77      /**
  78       * Constructor
  79       *
  80       * @param string $apiKey Akismet API key
  81       * @param string $blog Blog URL
  82       * @return void
  83       */
  84      public function __construct($apiKey, $blog)
  85      {
  86          $this->setBlogUrl($blog)
  87               ->setApiKey($apiKey)
  88               ->setUserAgent('Zend Framework/' . Zend_Version::VERSION . ' | Akismet/1.11');
  89      }
  90  
  91      /**
  92       * Retrieve blog URL
  93       *
  94       * @return string
  95       */
  96      public function getBlogUrl()
  97      {
  98          return $this->_blogUrl;
  99      }
 100  
 101      /**
 102       * Set blog URL
 103       *
 104       * @param string $blogUrl
 105       * @return Zend_Service_Akismet
 106       * @throws Zend_Service_Exception if invalid URL provided
 107       */
 108      public function setBlogUrl($blogUrl)
 109      {
 110          require_once 'Zend/Uri.php';
 111          if (!Zend_Uri::check($blogUrl)) {
 112              require_once 'Zend/Service/Exception.php';
 113              throw new Zend_Service_Exception('Invalid url provided for blog');
 114          }
 115  
 116          $this->_blogUrl = $blogUrl;
 117          return $this;
 118      }
 119  
 120      /**
 121       * Retrieve API key
 122       *
 123       * @return string
 124       */
 125      public function getApiKey()
 126      {
 127          return $this->_apiKey;
 128      }
 129  
 130      /**
 131       * Set API key
 132       *
 133       * @param string $apiKey
 134       * @return Zend_Service_Akismet
 135       */
 136      public function setApiKey($apiKey)
 137      {
 138          $this->_apiKey = $apiKey;
 139          return $this;
 140      }
 141  
 142      /**
 143       * Retrieve charset
 144       *
 145       * @return string
 146       */
 147      public function getCharset()
 148      {
 149          return $this->_charset;
 150      }
 151  
 152      /**
 153       * Set charset
 154       *
 155       * @param string $charset
 156       * @return Zend_Service_Akismet
 157       */
 158      public function setCharset($charset)
 159      {
 160          $this->_charset = $charset;
 161          return $this;
 162      }
 163  
 164      /**
 165       * Retrieve TCP/IP port
 166       *
 167       * @return int
 168       */
 169      public function getPort()
 170      {
 171          return $this->_port;
 172      }
 173  
 174      /**
 175       * Set TCP/IP port
 176       *
 177       * @param int $port
 178       * @return Zend_Service_Akismet
 179       * @throws Zend_Service_Exception if non-integer value provided
 180       */
 181      public function setPort($port)
 182      {
 183          if (!is_int($port)) {
 184              require_once 'Zend/Service/Exception.php';
 185              throw new Zend_Service_Exception('Invalid port');
 186          }
 187  
 188          $this->_port = $port;
 189          return $this;
 190      }
 191  
 192      /**
 193       * Retrieve User Agent string
 194       *
 195       * @return string
 196       */
 197      public function getUserAgent()
 198      {
 199          return $this->_userAgent;
 200      }
 201  
 202      /**
 203       * Set User Agent
 204       *
 205       * Should be of form "Some user agent/version | Akismet/version"
 206       *
 207       * @param string $userAgent
 208       * @return Zend_Service_Akismet
 209       * @throws Zend_Service_Exception with invalid user agent string
 210       */
 211      public function setUserAgent($userAgent)
 212      {
 213          if (!is_string($userAgent)
 214              || !preg_match(":^[^\n/]*/[^ ]* \| Akismet/[0-9\.]*$:i", $userAgent))
 215          {
 216              require_once 'Zend/Service/Exception.php';
 217              throw new Zend_Service_Exception('Invalid User Agent string; must be of format "Application name/version | Akismet/version"');
 218          }
 219  
 220          $this->_userAgent = $userAgent;
 221          return $this;
 222      }
 223  
 224      /**
 225       * Post a request
 226       *
 227       * @param string $host
 228       * @param string $path
 229       * @param array  $params
 230       * @return mixed
 231       */
 232      protected function _post($host, $path, array $params)
 233      {
 234          $uri    = 'http://' . $host . ':' . $this->getPort() . $path;
 235          $client = self::getHttpClient();
 236          $client->setUri($uri);
 237          $client->setConfig(array(
 238              'useragent'    => $this->getUserAgent(),
 239          ));
 240  
 241          $client->setHeaders(array(
 242              'Host'         => $host,
 243              'Content-Type' => 'application/x-www-form-urlencoded; charset=' . $this->getCharset()
 244          ));
 245          $client->setParameterPost($params);
 246  
 247          $client->setMethod(Zend_Http_Client::POST);
 248          return $client->request();
 249      }
 250  
 251      /**
 252       * Verify an API key
 253       *
 254       * @param string $key Optional; API key to verify
 255       * @param string $blog Optional; blog URL against which to verify key
 256       * @return boolean
 257       */
 258      public function verifyKey($key = null, $blog = null)
 259      {
 260          if (null === $key) {
 261              $key = $this->getApiKey();
 262          }
 263  
 264          if (null === $blog) {
 265              $blog = $this->getBlogUrl();
 266          }
 267  
 268          $response = $this->_post('rest.akismet.com', '/1.1/verify-key', array(
 269              'key'  => $key,
 270              'blog' => $blog
 271          ));
 272  
 273          return ('valid' == $response->getBody());
 274      }
 275  
 276      /**
 277       * Perform an API call
 278       *
 279       * @param string $path
 280       * @param array $params
 281       * @return Zend_Http_Response
 282       * @throws Zend_Service_Exception if missing user_ip or user_agent fields
 283       */
 284      protected function _makeApiCall($path, $params)
 285      {
 286          if (empty($params['user_ip']) || empty($params['user_agent'])) {
 287              require_once 'Zend/Service/Exception.php';
 288              throw new Zend_Service_Exception('Missing required Akismet fields (user_ip and user_agent are required)');
 289          }
 290  
 291          if (!isset($params['blog'])) {
 292              $params['blog'] = $this->getBlogUrl();
 293          }
 294  
 295          return $this->_post($this->getApiKey() . '.rest.akismet.com', $path, $params);
 296      }
 297  
 298      /**
 299       * Check a comment for spam
 300       *
 301       * Checks a comment to see if it is spam. $params should be an associative
 302       * array with one or more of the following keys (unless noted, all keys are
 303       * optional):
 304       * - blog: URL of the blog. If not provided, uses value returned by {@link getBlogUrl()}
 305       * - user_ip (required): IP address of comment submitter
 306       * - user_agent (required): User Agent used by comment submitter
 307       * - referrer: contents of HTTP_REFERER header
 308       * - permalink: location of the entry to which the comment was submitted
 309       * - comment_type: typically, one of 'blank', 'comment', 'trackback', or 'pingback', but may be any value
 310       * - comment_author: name submitted with the content
 311       * - comment_author_email: email submitted with the content
 312       * - comment_author_url: URL submitted with the content
 313       * - comment_content: actual content
 314       *
 315       * Additionally, Akismet suggests returning the key/value pairs in the
 316       * $_SERVER array, and these may be included in the $params.
 317       *
 318       * This method implements the Akismet comment-check REST method.
 319       *
 320       * @param array $params
 321       * @return boolean
 322       * @throws Zend_Service_Exception with invalid API key
 323       */
 324      public function isSpam($params)
 325      {
 326          $response = $this->_makeApiCall('/1.1/comment-check', $params);
 327  
 328          $return = trim($response->getBody());
 329  
 330          if ('invalid' == $return) {
 331              require_once 'Zend/Service/Exception.php';
 332              throw new Zend_Service_Exception('Invalid API key');
 333          }
 334  
 335          if ('true' == $return) {
 336              return true;
 337          }
 338  
 339          return false;
 340      }
 341  
 342      /**
 343       * Submit spam
 344       *
 345       * Takes the same arguments as {@link isSpam()}.
 346       *
 347       * Submits known spam content to Akismet to help train it.
 348       *
 349       * This method implements Akismet's submit-spam REST method.
 350       *
 351       * @param array $params
 352       * @return void
 353       * @throws Zend_Service_Exception with invalid API key
 354       */
 355      public function submitSpam($params)
 356      {
 357          $response = $this->_makeApiCall('/1.1/submit-spam', $params);
 358          $value    = trim($response->getBody());
 359          if ('invalid' == $value) {
 360              require_once 'Zend/Service/Exception.php';
 361              throw new Zend_Service_Exception('Invalid API key');
 362          }
 363      }
 364  
 365      /**
 366       * Submit ham
 367       *
 368       * Takes the same arguments as {@link isSpam()}.
 369       *
 370       * Submits a comment that has been falsely categorized as spam by Akismet
 371       * as a false positive, telling Akismet's filters not to filter such
 372       * comments as spam in the future.
 373       *
 374       * Unlike {@link submitSpam()} and {@link isSpam()}, a valid API key is
 375       * never necessary; as a result, this method never throws an exception
 376       * (unless an exception happens with the HTTP client layer).
 377       *
 378       * this method implements Akismet's submit-ham REST method.
 379       *
 380       * @param array $params
 381       * @return void
 382       */
 383      public function submitHam($params)
 384      {
 385          $response = $this->_makeApiCall('/1.1/submit-ham', $params);
 386      }
 387  }