Services_Blogging
[ class tree: Services_Blogging ] [ index: Services_Blogging ] [ all elements ]

Source for file Blogging.php

Documentation is available at Blogging.php

  1. <?php
  2. /**
  3. * Part of the Services_Blogging package.
  4. *
  5. * PHP version 5
  6. *
  7. @category Services
  8. @package  Services_Blogging
  9. @author   Christian Weiske <cweiske@php.net>
  10. @author   Anant Narayanan <anant@php.net>
  11. @license  http://www.gnu.org/copyleft/lesser.html  LGPL License 2.1
  12. @version  CVS: $Id$
  13. @link     http://pear.php.net/package/Services_Blogging
  14. */
  15.  
  16. require_once 'Services/Blogging/Exception.php';
  17.  
  18. /**
  19. * Generic package for several Blogging APIs.
  20. *
  21. * Create a new instance via
  22. * Services_Blogging::factory($driver, $username, $password, $server, $path),
  23. * or more easy via
  24. * Services_Blogging::discoverDriver($url, $username, $password) .
  25. *
  26. * Note that some Blogging APIs allow multiple blogs with one
  27. * account. These drivers implement Services_Blogging_MultipleBlogsInterface
  28. * - you need to call setBlogId($id) before you can use the driver in that case.
  29. *
  30. @category Services
  31. @package  Services_Blogging
  32. @author   Christian Weiske <cweiske@php.net>
  33. @author   Anant Narayanan <anant@php.net>
  34. @license  http://www.gnu.org/copyleft/lesser.html  LGPL License 2.1
  35. @link     http://pear.php.net/package/Services_Blogging
  36. *
  37. @todo
  38. *  Missing drivers
  39. *  - MovableType
  40. *  - Conversant
  41. *  - Manila
  42. *  - MetaWiki
  43. *  - Antville
  44. */
  45. {
  46.     /**
  47.     * Exception code for a problem with the driver:
  48.     * - driver does not exist
  49.     * - driver does not extend base driver class
  50.     */
  51.     const ERROR_DRIVER = 101;
  52.  
  53.     /**
  54.     * Exception code when the bloggin system does not support autodiscovery
  55.     */
  56.     const ERROR_BLOGHASNTAUTODISCOVERY = 102;
  57.  
  58.     /**
  59.     * Exception code when autodiscovery succeeded, but not matching driver
  60.     * could be found
  61.     */
  62.     const ERROR_NOSUPPORTEDDRIVER = 103;
  63.  
  64.     /**
  65.     * Exception code when something (method, property) is not supported.
  66.     */
  67.     const ERROR_NOTSUPPORTED = 104;
  68.  
  69.     /**
  70.      * USER_AGENT to send along during requests.
  71.      */
  72.     const USER_AGENT = 'PHP/Services_Blogging-0.2.4';
  73.  
  74.  
  75.     /**
  76.     * The factory function that instantiates the appropriate class and returns
  77.     * the object, so that further methods may be executed. This function serves
  78.     * as the single entry point for the class.
  79.     *
  80.     * @param string $driver   The driver name, currently either 'Blogger',
  81.     *                          'MetaWeblog' or 'LiveJournal'.
  82.     * @param string $username The username of the blog account to connect to.
  83.     * @param string $password The password of the blog account to connect to.
  84.     * @param string $server   The URI of the blog's server with protocol.
  85.     * @param string $path     The location of the XML-RPC server script.
  86.     *
  87.     * @return Services_Blogging_Driver Blogging driver instance
  88.     *
  89.     * @throws Services_Blogging_Exception If authentication fails
  90.     * @throws Services_Blogging_Exception If the driver does not exist.
  91.     * @throws Services_Blogging_Exception If the driver does not extend the
  92.     *                                      base driver class
  93.     *                                      Services_Blogging_Driver
  94.     */
  95.     public static function factory($driver$username$password$server$path)
  96.     {
  97.         //security measurement
  98.         $driver preg_replace('/[^a-z0-9_]/i'''$driver);
  99.  
  100.         include_once 'Services/Blogging/Driver/' $driver '.php';
  101.         $strClass 'Services_Blogging_Driver_' $driver;
  102.         if (!class_exists($strClass)) {
  103.             throw new Services_Blogging_Exception(
  104.                 'Invalid driver "' $driver '" specified!'self::ERROR_DRIVER
  105.             );
  106.         }
  107.         if (!is_subclass_of($strClass'Services_Blogging_Driver')) {
  108.             throw new Services_Blogging_Exception(
  109.                 'Driver class ' $strClass ' is not a child class'
  110.                 . ' of Services_Blogging_Driver'self::ERROR_DRIVER
  111.             );
  112.         }
  113.  
  114.         //handle slighly wrong user input: no path but slash in server
  115.         if ($path == null && substr($server-1== '/'{
  116.             $server substr($server0-1);
  117.         }
  118.  
  119.         $class = new $strClass($username$password$server$path);
  120.         return $class;
  121.     }//public static function factory($driver, $username, $password, $server, $path)
  122.  
  123.  
  124.  
  125.     /**
  126.     * Autodiscover the driver settings from the given blog URL
  127.     * and create a driver instance.
  128.     *
  129.     * @param string $url      Blog URL
  130.     * @param string $username Username for the blog account
  131.     * @param string $password Password for the blog account
  132.     *
  133.     * @return Services_Blogging_Driver The driver object if all goes ok
  134.     *
  135.     * @throws Services_Blogging_Exception If an error occured
  136.     */
  137.     public static function discoverDriver($url$username$password)
  138.     {
  139.         $settings = self::discoverSettings($url);
  140.         if ($settings === false{
  141.             throw new Services_Blogging_Exception(
  142.                 'Autodiscovery of settings not supported by the blog',
  143.                 self::ERROR_BLOGHASNTAUTODISCOVERY
  144.             );
  145.         }
  146.         $driver = self::getBestAvailableDriver($settings);
  147.         if ($driver === false{
  148.             throw new Services_Blogging_Exception(
  149.                 'None of the supported drivers available',
  150.                 self::ERROR_NOSUPPORTEDDRIVER
  151.             );
  152.         }
  153.  
  154.         return self::factory(
  155.             $driver,
  156.             $username,
  157.             $password,
  158.             $settings['apis'][$driver]['server'],
  159.             $settings['apis'][$driver]['path']
  160.         );
  161.     }//public static function discoverDriver($url, $username, $password)
  162.  
  163.  
  164.  
  165.     /**
  166.     * Tries to auto-discover the driver settings for the blog
  167.     * at the given URL.
  168.     * Internally, an RSD page is tried to load and read.
  169.     *
  170.     * @param string $url Url of the blog
  171.     *
  172.     * @return mixed FALSE if nothing found, OR array of settings:
  173.     *                   - engineName
  174.     *                   - engineLink
  175.     *                   - homePageLink
  176.     *                   - apis => array (key is name
  177.     *                       - name
  178.     *                       - preferred
  179.     *                       - apiLink (url)
  180.     *                       - server (for factory())
  181.     *                       - path   (for factory())
  182.     *
  183.     *  @link http://archipelago.phrasewise.com/display?page=oldsite/1330.html
  184.     */
  185.     public static function discoverSettings($url)
  186.     {
  187.         $content file_get_contents($url);
  188.         if ($content === false{
  189.             return false;
  190.         }
  191.  
  192.         //search for a line like this:
  193.         //<link rel="EditURI" type="application/rsd+xml" title="RSD"
  194.         // href="http://blog.bogo/xmlrpc.php?rsd" />
  195.         if (!preg_match_all('|<link\\s+rel="EditURI".+href="(.+?)"|',
  196.                 $content$matches)
  197.         {
  198.             return false;
  199.         }
  200.  
  201.         $rsdUrl reset($matches[1]);
  202.         $root   simplexml_load_string(file_get_contents($rsdUrl));
  203.         if ($root === false{
  204.             return false;
  205.         }
  206.  
  207.         $apis = array();
  208.         foreach ($root->service->apis->api as $api{
  209.             $ap         = array();
  210.             $ap['name'= (string)$api['name'];
  211.             if ($ap['name'== 'Movable Type'{
  212.                 $ap['name''MovableType';
  213.             }
  214.             $ap['preferred'$api['preferred'== 1 || $api['preferred'== 'true';
  215.             $ap['apiLink']   = (string)$api['apiLink'];
  216.  
  217.             //try to get server and path
  218.             $dslashpos strpos($ap['apiLink']'//');
  219.             if ($dslashpos === false{
  220.                 $nBegin = 0;
  221.             else {
  222.                 $nBegin $dslashpos + 2;
  223.             }
  224.             $slashpos     strpos($ap['apiLink']'/'$nBegin);
  225.             $ap['server'substr($ap['apiLink']0$slashpos);
  226.             $ap['path']   substr($ap['apiLink']$slashpos);
  227.  
  228.             $apis[$ap['name']] $ap;
  229.         }
  230.  
  231.         $data = array(
  232.             'engineName'   => (string)$root->service->engineName,
  233.             'engineLink'   => (string)$root->service->engineLink,
  234.             'homePageLink' => (string)$root->service->homePageLink,
  235.             'apis'         => $apis
  236.         );
  237.         return $data;
  238.     }//public static function discoverSettings($url)
  239.  
  240.  
  241.  
  242.     /**
  243.     * Tries to return the best available driver for the given
  244.     * settings array. The settings array is returned by
  245.     * Services_Blogging::discoverSettings()
  246.     *
  247.     * @param array $arSettings Settings array
  248.     *
  249.     * @return string The driver to use, false if none found
  250.     */
  251.     public static function getBestAvailableDriver($arSettings)
  252.     {
  253.         if (isset($arSettings['apis'])) {
  254.             $arSettings $arSettings['apis'];
  255.         }
  256.         //find preferred one
  257.         $driver = null;
  258.         foreach ($arSettings as $id => $api{
  259.             if ($api['preferred'=== true{
  260.                 if (self::driverExists($api['name'])) {
  261.                     return $api['name'];
  262.                 }
  263.                 unset($arSettings[$id]);
  264.             }
  265.         }
  266.         foreach ($arSettings as $id => $api{
  267.             if (self::driverExists($api['name'])) {
  268.                 return $api['name'];
  269.             }
  270.         }
  271.  
  272.         return false;
  273.     }//public static function getBestAvailableDriver($arSettings)
  274.  
  275.  
  276.  
  277.     /**
  278.     * Tries to include the driver file and checks if
  279.     * the driver class exists.
  280.     *
  281.     * @param string $driver Driver to check
  282.     *
  283.     * @return boolean If the driver exists
  284.     */
  285.     protected static function driverExists($driver)
  286.     {
  287.         @include_once 'Services/Blogging/Driver/' $driver '.php';
  288.         return class_exists('Services_Blogging_Driver_' $driver);
  289.     }//protected static function driverExists($driver)
  290.  
  291. }//class Services_Blogging
  292. ?>

Documentation generated on Sat, 10 Dec 2011 15:30:27 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.