path: root/modules/blogapi/blogapi.module

<?php
// $Id$

/**
 * @file
 * Enable users to post using applications that support XML-RPC blog APIs.
 */

/**
 * Implementation of hook_help().
 */
function blogapi_help($section) {
  switch ($section) {
    case 'admin/help#blogapi':
      return t('<p>This module adds support for several XML-RPC based blogging APIs. Specifically, it currently implements the %bloggerAPI, %metaweblogAPI, and most of the %moveabletype extensions.  This allows users to contribute to drupal using external GUI applications, which can often offer richer functionality that online forms based editing.</p>', array('%bloggerAPI' => '<a href="http://www.blogger.com/developers/api/1_docs/">Blogger API</a>', '%metaweblogAPI' => '<a href="http://www.xmlrpc.com/metaWeblogApi">MetaWeblog API</a>', '%moveabletype' => '<a href="http://www.movabletype.org/docs/mtmanual_programmatic.html">Moveable Type API</a>'));
    case 'admin/modules#description':
      return t('Enable users to post using applications that support XML-RPC blog APIs.');
  }
}

/**
 * Implementation of hook_xmlrpc().
 */
function blogapi_xmlrpc() {
  $methods = array('blogger.getUsersBlogs' => array('function' => 'blogapi_get_users_blogs'),
                   'blogger.getUserInfo' => array('function' => 'blogapi_get_user_info'),
                   'blogger.newPost' => array('function' => 'blogapi_new_post'),
                   'blogger.editPost' => array('function' => 'blogapi_edit_post'),
                   'blogger.deletePost' => array('function' => 'blogapi_delete_post'),
                   'blogger.getRecentPosts' => array('function' => 'blogapi_get_recent_posts'),
                   'metaWeblog.newPost' => array('function' => 'blogapi_new_post'),
                   'metaWeblog.editPost' => array('function' => 'blogapi_edit_post'),
                   'metaWeblog.getPost' => array('function' => 'blogapi_get_post'),
                   'metaWeblog.newMediaObject' => array('function' => 'blogapi_new_media_object'),
                   'metaWeblog.getCategories' => array('function' => 'blogapi_get_category_list'),
                   'metaWeblog.getRecentPosts' => array('function' => 'blogapi_get_recent_posts'),
                   'mt.getRecentPostTitles' => array('function' => 'blogapi_get_recent_post_titles'),
                   'mt.getCategoryList' => array('function' => 'blogapi_get_category_list'),
                   'mt.getPostCategories' => array('function' => 'blogapi_get_post_categories'),
                   'mt.setPostCategories' => array('function' => 'blogapi_set_post_categories'),
                   'mt.supportedMethods' => array('function' => 'blogapi_supported_methods'),
                   'mt.supportedTextFilters' => array('function' => 'blogapi_supported_text_filters'),
                   'mt.getTrackbackPings' => array('function' => 'blogapi_get_trackback_pings'),
                   'mt.publishPost' => array('function' => 'blogapi_publish_post')
                   );

  return $methods;
}

/**
 * Blogging API callback. Finds the URL of a user's blog.
 */
function blogapi_get_users_blogs($req_params) {
  $params = blogapi_convert($req_params);
  // Remove unused appkey from bloggerAPI.
  if (count($params) == 6) {
    $params = array_slice($params, 1);
  }

  $user = blogapi_validate_user($params[1], $params[2]);
  if ($user->uid) {
    $struct = new xmlrpcval(array('url' => new xmlrpcval(url('blog/' . $user->uid, NULL, NULL, true)),
                                  'blogid' => new xmlrpcval($user->uid),
                                  'blogName' => new xmlrpcval($user->name . "'s blog")),
                            'struct');
    $resp = new xmlrpcval(array($struct), 'array');
    return new xmlrpcresp($resp);
  }
  else {
    return blogapi_error($user);
  }
}

/**
 * Blogging API callback. Returns profile information about a user.
 */
function blogapi_get_user_info($req_params) {
  $params = blogapi_convert($req_params);

  $user = blogapi_validate_user($params[1], $params[2]);

  if ($user->uid) {
    $name = explode(' ', $user->realname ? $user->realname : $user->name, 2);
    $struct = new xmlrpcval(array('userid' => new xmlrpcval($user->uid, 'string'),
                                  'lastname' => new xmlrpcval($name[1], 'string'),
                                  'firstname' => new xmlrpcval($name[0], 'string'),
                                  'nickname' => new xmlrpcval($user->name, 'string'),
                                  'email' => new xmlrpcval($user->mail, 'string'),
                                  'url' => new xmlrpcval(url('blog/view/' . $user->uid, NULL, NULL, true), 'string')),
                            'struct');
    return new xmlrpcresp($struct);
  }
  else {
    return blogapi_error($user);
  }
}

/**
 * Blogging API callback. Inserts a new blog post as a node.
 */
function blogapi_new_post($req_params) {
  $params = blogapi_convert($req_params);

  // Remove unused appkey from bloggerAPI.
  if (count($params) == 6) {
    $params = array_slice($params, 1);
  }

  $user = blogapi_validate_user($params[1], $params[2]);
  if (!$user->uid) {
    return blogapi_error($user);
  }

  $edit = array();
  $edit['type'] = 'blog';
  $edit['uid'] = $user->uid;
  $edit['name'] = $user->name;
  $edit['promote'] = variable_get('node_promote_blog', 1);
  $edit['comment'] = variable_get('node_comment_blog', 2);
  $edit['moderate'] = variable_get('node_moderate_blog', 0);
  $edit['revision'] = variable_get('node_revision_blog', 0);
  $edit['format'] = FILTER_FORMAT_DEFAULT;
  $edit['status'] = $params[4];

  // check for bloggerAPI vs. metaWeblogAPI
  if (is_array($params[3])) {
    $edit['title'] = $params[3]['title'];
    $edit['body'] = $params[3]['description'];
    _blogapi_mt_extra($edit, $params[3]);
  }
  else {
    $edit['title'] = blogapi_blogger_title($params[3]);
    $edit['body'] = $params[3];
  }

  if (!valid_input_data($edit['title'], $edit['body'])) {
    return blogapi_error(t('Terminated request because of suspicious input data.'));
  }

  $node = node_validate($edit);

  if ($errors = form_get_errors()) {
    return blogapi_error(implode("\n", $errors));
  }

  if (!node_access('create', $node)) {
    return blogapi_error(message_access());
  }

  $nid = node_save($node);
  if ($nid) {
    watchdog('special', t('%type: added %title using blog API.', array('%type' => '<em>'. t($node->type) .'</em>', '%title' => "<em>$node->title</em>")), l(t('view'), "node/$nid"));
    return new xmlrpcresp(new xmlrpcval($nid, 'string'));
  }

  return blogapi_error(t('Error storing post.'));
}

/**
 * Blogging API callback. Modifies the specified blog node.
 */
function blogapi_edit_post($req_params) {
  $params = blogapi_convert($req_params);
  if (count($params) == 6) {
    $params = array_slice($params, 1);
  }

  $user = blogapi_validate_user($params[1], $params[2]);

  if (!$user->uid) {
    return blogapi_error($user);
  }

  $node = node_load(array('nid' => $params[0]));
  if (!$node) {
    return blogapi_error(message_na());
  }

  if (!node_access('update', $node)) {
    return blogapi_error(message_access());
  }

  $node->status = $params[4];

  // check for bloggerAPI vs. metaWeblogAPI
  if (is_array($params[3])) {
    $node->title = $params[3]['title'];
    $node->body = $params[3]['description'];
    _blogapi_mt_extra($node, $params[3]);
  }
  else {
    $node->title = blogapi_blogger_title($params[3]);
    $node->body = $params[3];
  }

  if (!valid_input_data($title, $body)) {
    return blogapi_error(t('Terminated request because of suspicious input data.'));
  }

  $node = node_validate($node);

  if ($errors = form_get_errors()) {
    return blogapi_error(implode("\n", $errors));
  }

  $terms = module_invoke('taxonomy', 'node_get_terms', $node->nid, 'tid');
  foreach ($terms as $term) {
    $node->taxonomy[] = $term->tid;
  }
  $nid = node_save($node);
  if ($nid) {
    watchdog('special', t('%type: updated %title using blog API.', array('%type' => '<em>'. t($node->type) .'</em>', '%title' => "<em>$node->title</em>")), l(t('view'), "node/$nid"));
    return new xmlrpcresp(new xmlrpcval(true, 'boolean'));
  }

  return blogapi_error(t('Error storing post.'));
}

/**
 * Blogging API callback. Returns a specified blog node.
 */
function blogapi_get_post($req_params) {
  $params = blogapi_convert($req_params);
  $user = blogapi_validate_user($params[1], $params[2]);
  if (!$user->uid) {
    return blogapi_error($user);
  }

  $node = node_load(array('nid' => $params[0]));

  $blog = _blogapi_get_post($node, true);

  return new xmlrpcresp($blog);
}

/**
 * Blogging API callback. Removes the specified blog node.
 */
function blogapi_delete_post($req_params) {
  $params = blogapi_convert($req_params);

  $user = blogapi_validate_user($params[2], $params[3]);
  if (!$user->uid) {
    return blogapi_error($user);
  }

  $ret = node_delete(array('nid' => $params[1], 'confirm' => 1));
  return new xmlrpcresp(new xmlrpcval(true, 'boolean'));
}

/**
 * Blogging API callback. Inserts a file into Drupal.
 */
function blogapi_new_media_object($req_params) {
  $params = blogapi_convert($req_params);

  $user = blogapi_validate_user($params[1], $params[2]);
  if (!$user->uid) {
    return blogapi_error($user);
  }

  $name = basename($params[3]['name']);
  $data = $params[3]['bits'];

  if (!$data) {
    return blogapi_error(t('No file sent.'));
  }

  if (!$file = file_save_data($data, $name)) {
    return blogapi_error(t('Error storing file.'));
  }

  // Return the successful result.
  $result = new xmlrpcval(array('url' => new xmlrpcval(file_create_url($file), 'string')), 'struct');
  return new xmlrpcresp($result);
}

/**
 * Blogging API callback. Returns a list of the taxonomy terms that can be
 * associated with a blog node.
 */
function blogapi_get_category_list($req_params) {
  $vocabularies = module_invoke('taxonomy', 'get_vocabularies', 'blog', 'vid');
  $categories = array();
  if ($vocabularies) {
    foreach ($vocabularies as $vocabulary) {
      $terms = module_invoke('taxonomy', 'get_tree', $vocabulary->vid, 0, -1);
      foreach ($terms as $term) {
        $term_name = $term->name;
        foreach (module_invoke('taxonomy', 'get_parents', $term->tid, 'tid') as $parent) {
          $term_name = $parent->name . '/' . $term_name;
        }
        $categories[] = new xmlrpcval(array('categoryName' => new xmlrpcval($term_name, 'string'),
                                            'categoryId' => new xmlrpcval($term->tid, 'string')),
                                      'struct');
      }
    }
  }
  return new xmlrpcresp(new xmlrpcval($categories, 'array'));
}

/**
 * Blogging API callback. Returns a list of the taxonomy terms that are
 * assigned to a particular node.
 */
function blogapi_get_post_categories($req_params) {
  $params = blogapi_convert($req_params);
  $user = blogapi_validate_user($params[1], $params[2]);
  if (!$user->uid) {
    return blogapi_error($user);
  }

  $terms = module_invoke('taxonomy', 'node_get_terms', $params[0], 'tid');
  $categories = array();
  foreach ($terms as $term) {
    $term_name = $term->name;
    foreach (module_invoke('taxonomy', 'get_parents', $term->tid, 'tid') as $parent) {
      $term_name = $parent->name . '/' . $term_name;
    }
    $categories[] = new xmlrpcval(array('categoryName' => new xmlrpcval($term_name, 'string'),
                                        'categoryId' => new xmlrpcval($term->tid, 'string'),
                                        'isPrimary' => new xmlrpcval(true, 'boolean')),
                                  'struct');
  }
  return new xmlrpcresp(new xmlrpcval($categories, 'array'));
}

/**
 * Blogging API callback. Assigns taxonomy terms to a particular node.
 */
function blogapi_set_post_categories($req_params) {
  $params = blogapi_convert($req_params);
  $user = blogapi_validate_user($params[1], $params[2]);
  if (!$user->uid) {
    return blogapi_error($user);
  }

  $nid = $params[0];
  $terms = array();
  foreach ($params[3] as $category) {
    $terms[] = $category['categoryId']->scalarval();
  }
  module_invoke('taxonomy', 'node_save', $nid, $terms);
  return new xmlrpcresp(new xmlrpcval(true, 'boolean'));
}

/**
 * Blogging API callback. Returns the latest few postings in a user's blog. $bodies TRUE
 * <a href="http://movabletype.org/docs/mtmanual_programmatic.html#item_mt%2EgetRecentPostTitles">
 * returns a bandwidth-friendly list</a>.
 */
function blogapi_get_recent_posts($req_params, $bodies = TRUE) {
  $params = blogapi_convert($req_params);

  // Remove unused appkey (from bloggerAPI).
  if (count($params) == 5) {
    $params = array_slice($params, 1);
  }
  $user = blogapi_validate_user($params[1], $params[2]);
  if (!$user->uid) {
    return blogapi_error($user);
  }

  $result = db_query_range('SELECT n.nid, n.title,'. ($bodies ? ' n.body,' : '') ." n.created, u.name FROM {node} n, {users} u WHERE n.uid=u.uid AND n.type = 'blog' AND n.uid = %d ORDER BY n.created DESC",  $user->uid, 0, $params[3]);
  while ($blog = db_fetch_object($result)) {
    $xmlrpcval = _blogapi_get_post($blog, $bodies);
    $blogs[] = $xmlrpcval;
  }
  return new xmlrpcresp(new xmlrpcval($blogs, 'array'));
}

// see above
function blogapi_get_recent_post_titles($req_params) {
  return blogapi_get_recent_posts($req_params, TRUE);
}

/**
 * Blogging API callback. Sends a list of supported methods to the client.
 */
function blogapi_supported_methods($req_params) {
  $methods = array_keys(blogapi_xmlrpc());

  $output = array();
  foreach ($methods as $method) {
    $output[] = new xmlrpcval($method, 'string');
  }
  return new xmlrpcresp(new xmlrpcval($output, 'array'));
}

/**
 * Blogging API callback. Sends a list of available input formats.
 */
function blogapi_supported_text_filters($req_params) {
  global $user;

  // NOTE: we're only using anonymous' formats because the MT spec
  // does not allow for per-user formats.
  $formats = filter_formats();

  $filters = array();
  foreach ($formats as $format) {
    $filter['key'] = new xmlrpcval($format->format, 'string');
    $filter['label'] = new xmlrpcval($format->name, 'string');
    $filters[] = new xmlrpcval($filter, 'struct');
  }

  return new xmlrpcresp(new xmlrpcval($filters, 'array'));
}

/**
 * Blogging API callback. Can not be implemented without support from
 * trackback module.
 */
function blogapi_get_trackback_pings($req_params) {
  return blogapi_error(t('Not implemented.'));
}

/**
 * Blogging API callback. Publishes the given node
 */
function blogapi_publish_post($req_params) {
  $params = blogapi_convert($req_params);

  $user = blogapi_validate_user($params[1], $params[2]);
  $node = node_load(array('nid' => $params[0]));
  if (!$node) {
    return blogapi_error(t('Invalid post.'));
  }

  $node->status = 1;
  if (!node_access('update', $node)) {
    return blogapi_error(message_access());
  }

  node_save($node);

  return new xmlrpcresp(new xmlrpcval(true, 'boolean'));
}


/**
 * Process the parameters to an XMLRPC callback, and return them as an array.
 */
function blogapi_convert($params) {
  $cparams = array();
  $num_params= $params->getNumParams();

  for ($i = 0; $i < $num_params; $i++) {
    $sn = $params->getParam($i);
    $cparams[] = $sn->getval();
  }

  return $cparams;
}

/**
 * Prepare an error message for returning to the XMLRPC caller.
 */
function blogapi_error($message) {
  global $xmlrpcusererr;

  if (!is_array($message)) {
    $message = array($message);
  }

  $message = implode(' ', $message);

  return new xmlrpcresp(0, $xmlrpcusererr + 1, strip_tags($message));
}

/**
 * Ensure that the given user has permission to edit a blog.
 */
function blogapi_validate_user($username, $password) {
  global $user;

  $user = user_authenticate($username, $password);

  if ($user->uid) {
    if (user_access('edit own blog', $user)) {
      return $user;
    }
    else {
      return message_access();
    }
  }
  else {
    return t('Wrong username or password.');
  }
}

/**
 * For the blogger API, extract the node title from the contents field.
 */
function blogapi_blogger_title(&$contents) {
  if (eregi('<title>([^<]*)</title>', $contents, $title)) {
    $title = strip_tags($title[0]);
    $contents = ereg_replace('<title>[^<]*</title>', '', $contents);
  }
  else {
    list($title, $rest) = explode("\n", $contents, 2);
  }
  return $title;
}

function blogapi_settings() {
  $output = form_select(t('XML-RPC Engine'), 'blogapi_engine', variable_get('blogapi_engine', 0), array(0 => 'Blogger', 1 => 'MetaWeblog', 2 => 'Movabletype'), t('RSD or Really-Simple-Discovery is a mechanism which allows external blogger tools to discover the APIs they can use to interact with Drupal. Here you can set the preferred method for blogger tools to interact with your site. The common XML-RPC engines are Blogger, MetaWeblog and Movabletype. If you are not sure which is the correct setting, choose Blogger.'));
  return $output;
}

function blogapi_menu($may_cache) {
  $items = array();

  if ($_GET['q'] == variable_get('site_frontpage', 'node')) {
    drupal_set_html_head('<link rel="EditURI" type="application/rsd+xml" title="RSD" href="' . url('blogapi/rsd', NULL, NULL, TRUE) . '" />');
  }

  if ($may_cache) {
    $items[] = array('path' => 'blogapi', 'title' => t('RSD'), 'callback' => 'blogapi_blogapi', 'access' => user_access('access_content'), 'type' => MENU_CALLBACK);
  }

  return $items;
}

function blogapi_blogapi() {
  switch (arg(1)) {
    case 'rsd':
      blogapi_rsd();
      break;
    default:
      drupal_not_found();
      break;
  }
}

function blogapi_rsd() {
  global $base_url;

  $xmlrpc = $base_url .'/'. 'xmlrpc.php';
  $base = url('', NULL, NULL, TRUE);
  $blogid = 1; # until we figure out how to handle multiple bloggers

  $metaweblog = 'false'; $blogger = 'false'; $mt = 'false';
  if (variable_get('blogapi_engine', 0) == 0) {
    $blogger = 'true';
  } else if (variable_get('blogapi_engine', 0) == 1) {
    $metaweblog = 'true';
  } else if (variable_get('blogapi_engine', 0) == 2) {
    $mt = 'true';
  }

  print <<<__RSD__
<?xml version="1.0"?>
<rsd version="1.0" xmlns="http://archipelago.phrasewise.com/rsd">
  <service>
    <engineName>Drupal</engineName>
    <engineLink>http://www.drupal.org/</engineLink>
    <homePageLink>$base</homePageLink>
    <apis>
      <api name="MetaWeblog" preferred="$metaweblog" apiLink="$xmlrpc" blogID="$blogid" />
      <api name="Blogger" preferred="$blogger" apiLink="$xmlrpc" blogID="$blogid" />
      <api name="Movabletype" preferred="$mt" apiLink="$xmlrpc" blogID="$blogid" />
    </apis>
  </service>
</rsd>
__RSD__;
}

/**
 * Handles extra information sent by clients according to MovableType's spec.
 */
function _blogapi_mt_extra(&$node, $struct) {
  if (is_array($node)) {
    $was_array = true;
    $node = array2object($node);
  }

  // mt_allow_comments
  if (array_key_exists('mt_allow_comments', $struct)) {
    switch ($struct['mt_allow_comments']) {
      case 0:
        $node->comment = 0;
        break;
      case 1:
        $node->comment = 2;
        break;
      case 2:
        $node->comment = 1;
        break;
    }
  }

  // merge the 3 body sections (description, mt_excerpt, mt_text_more) into
  // one body
  if ($struct['mt_excerpt']) {
    $node->body = $struct['mt_excerpt'] .'<!--break-->'.$node->body;
  }
  if ($struct['mt_text_more']) {
    $node->body = $node->body . '<!--extended-->' . $struct['mt_text_more'];
  }

  // mt_tb_ping_urls
  if (function_exists('trackback_send')) {
    if (is_array($struct['mt_tb_ping_urls'])) {
      foreach ($struct['mt_tb_ping_urls'] as $tb_ping_url) {
        $node->tb_url = $tb_ping_url->getVal();
        trackback_send($node);
        unset($node->tb_url); // make sure we don't ping twice
      }
    }
    else {
      $node->tb_url = $struct['mt_tb_ping_urls'];
    }
  }

  // mt_convert_breaks
  if ($struct['mt_convert_breaks']) {
    $node->format = $struct['mt_convert_breaks'];
  }

  // dateCreated
  if ($struct['dateCreated']) {
    $node->created = iso8601_decode($struct['dateCreated'], 1);
  }

  if ($was_array) {
    $node = object2array($node);
  }
}

function _blogapi_get_post($node, $bodies = true) {
  $xmlrpcval = array (
    'userid' => new xmlrpcval($node->name, 'string'),
    'dateCreated' => new xmlrpcval(iso8601_encode($node->created), 'dateTime.iso8601'),
    'title' => new xmlrpcval($node->title, 'string'),
    'postid' => new xmlrpcval($node->nid, 'string'),
    'link' => new xmlrpcval(url('node/'.$node->nid, NULL, NULL, true)),
    'permaLink' => new xmlrpcval(url('node/'.$node->nid, NULL, NULL, true)),
  );
  if ($bodies) {
    if ($node->comment = 1) {
      $comment = 2;
    }
    if ($node->comment = 2) {
      $comment = 1;
    }

    $xmlrpcval['content'] = new xmlrpcval("<title>$blog->title</title>$node->body", 'string');
    $xmlrpcval['description'] = new xmlrpcval($node->body, 'string');
    // Add MT specific fields
    $xmlrpcval['mt_allow_comments'] = new xmlrpcval($comment, 'int');
    $xmlrpcval['mt_convert_breaks'] = new xmlrpcval($node->format, 'string');
  }

  return new xmlrpcval($xmlrpcval, 'struct');
}
?>