root/branches/2.2/wp-app.php

<?php
/* 
 * wp-app.php - Atom Publishing Protocol support for WordPress
 * Original code by: Elias Torres, http://torrez.us/archives/2006/08/31/491/
 * Modified by: Dougal Campbell, http://dougal.gunters.org/
 *
 * Version: 1.0.5-dc
 */

define('APP_REQUEST', true);

require_once('wp-config.php');
require_once('wp-includes/post-template.php');

// Attempt to automatically detect whether to use querystring
// or PATH_INFO, based on our environment:
$use_querystring = $wp_version == 'MU' ? 1 : 0;

// If using querystring, we need to put the path together manually:
if ($use_querystring) {
    $GLOBALS['use_querystring'] = $use_querystring;
    $action = $_GET['action'];
    $eid = (int) $_GET['eid'];

    $_SERVER['PATH_INFO'] = $action;

    if ($eid) {
        $_SERVER['PATH_INFO'] .= "/$eid";
    }
} else {
    $_SERVER['PATH_INFO'] = str_replace( '/wp-app.php', '', $_SERVER['REQUEST_URI'] );
}

$app_logging = 0;

function log_app($label,$msg) {
    global $app_logging;
    if ($app_logging) {
        $fp = fopen( 'app.log', 'a+');
        $date = gmdate( 'Y-m-d H:i:s' );
        fwrite($fp, "\n\n$date - $label\n$msg\n");
        fclose($fp);
    }
}

if ( !function_exists('wp_set_current_user') ) :
function wp_set_current_user($id, $name = '') {
    global $current_user;

    if ( isset($current_user) && ($id == $current_user->ID) )
        return $current_user;

    $current_user = new WP_User($id, $name);

    return $current_user;
}
endif;

function wa_posts_where_include_drafts_filter($where) {
    $where = ereg_replace("post_author = ([0-9]+) AND post_status != 'draft'","post_author = \\1 AND post_status = 'draft'", $where);
    return $where;
}
add_filter('posts_where', 'wa_posts_where_include_drafts_filter');

class AtomEntry {
    var $links = array();
    var $categories = array();
}

class AtomParser {

    var $ATOM_CONTENT_ELEMENTS = array('content','summary','title','subtitle','rights');
    var $ATOM_SIMPLE_ELEMENTS = array('id','updated','published','draft');

    var $depth = 0;
    var $indent = 2;
    var $in_content;
    var $ns_contexts = array();
    var $ns_decls = array();
    var $is_xhtml = false;
    var $skipped_div = false;

    var $entry;

    function AtomParser() {

        $this->entry = new AtomEntry();
        $this->map_attrs_func = create_function('$k,$v', 'return "$k=\"$v\"";');
        $this->map_xmlns_func = create_function('$p,$n', '$xd = "xmlns"; if(strlen($n[0])>0) $xd .= ":{$n[0]}"; return "{$xd}=\"{$n[1]}\"";');
    }

    function parse() {

        global $app_logging;
        array_unshift($this->ns_contexts, array());

        $parser = xml_parser_create_ns();
        xml_set_object($parser, $this);
        xml_set_element_handler($parser, "start_element", "end_element");
        xml_parser_set_option($parser,XML_OPTION_CASE_FOLDING,0);
        xml_parser_set_option($parser,XML_OPTION_SKIP_WHITE,0);
        xml_set_character_data_handler($parser, "cdata");
        xml_set_default_handler($parser, "_default");
        xml_set_start_namespace_decl_handler($parser, "start_ns");
        xml_set_end_namespace_decl_handler($parser, "end_ns");

        $contents = "";

        $fp = fopen("php://input", "r");
        while(!feof($fp)) {
            $line = fgets($fp, 4096);
         
            if($app_logging) $contents .= $line;

            if(!xml_parse($parser, $line)) {
                log_app("xml_parse_error", "line: $line");
                $this->error = sprintf(__('XML error: %s at line %d')."\n",
                    xml_error_string(xml_get_error_code($xml_parser)),
                    xml_get_current_line_number($xml_parser));
                log_app("xml_parse_error", $this->error);
                return false;
            }
        }
        fclose($fp);

        xml_parser_free($parser);

        log_app("AtomParser->parse()",trim($contents));

        return true;
    }

    function start_element($parser, $name, $attrs) {

        $tag = array_pop(split(":", $name));

        array_unshift($this->ns_contexts, $this->ns_decls);

        $this->depth++;

        #print str_repeat(" ", $this->depth * $this->indent) . "start_element('$name')" ."\n";
        #print str_repeat(" ", $this->depth+1 * $this->indent) . print_r($this->ns_contexts,true) ."\n";

        if(!empty($this->in_content)) {
            $attrs_prefix = array();

            // resolve prefixes for attributes
            foreach($attrs as $key => $value) {
                $attrs_prefix[$this->ns_to_prefix($key)] = $this->xml_escape($value);
            }
            $attrs_str = join(' ', array_map($this->map_attrs_func, array_keys($attrs_prefix), array_values($attrs_prefix)));
            if(strlen($attrs_str) > 0) {
                $attrs_str = " " . $attrs_str;
            }

            $xmlns_str = join(' ', array_map($this->map_xmlns_func, array_keys($this->ns_contexts[0]), array_values($this->ns_contexts[0])));
            if(strlen($xmlns_str) > 0) {
                $xmlns_str = " " . $xmlns_str;
            }

            // handle self-closing tags (case: a new child found right-away, no text node)
            if(count($this->in_content) == 2) {
                array_push($this->in_content, ">");
            }
         
            array_push($this->in_content, "<". $this->ns_to_prefix($name) ."{$xmlns_str}{$attrs_str}");
        } else if(in_array($tag, $this->ATOM_CONTENT_ELEMENTS) || in_array($tag, $this->ATOM_SIMPLE_ELEMENTS)) {
            $this->in_content = array();
            $this->is_xhtml = $attrs['type'] == 'xhtml'; 
            array_push($this->in_content, array($tag,$this->depth));
        } else if($tag == 'link') {
            array_push($this->entry->links, $attrs);
        } else if($tag == 'category') {
            array_push($this->entry->categories, $attrs);
        }

        $this->ns_decls = array();
    }

    function end_element($parser, $name) {

        $tag = array_pop(split(":", $name));

        if(!empty($this->in_content)) {
            if($this->in_content[0][0] == $tag && 
            $this->in_content[0][1] == $this->depth) {
                array_shift($this->in_content);
                if($this->is_xhtml) {
                    $this->in_content = array_slice($this->in_content, 2, count($this->in_content)-3);
                }
                $this->entry->$tag = join('',$this->in_content);
                $this->in_content = array();
            } else {
                $endtag = $this->ns_to_prefix($name);
                if (strpos($this->in_content[count($this->in_content)-1], '<' . $endtag) !== false) {
                    array_push($this->in_content, "/>");
                } else {
                    array_push($this->in_content, "</$endtag>");
                }
            }
        }

        array_shift($this->ns_contexts);

        #print str_repeat(" ", $this->depth * $this->indent) . "end_element('$name')" ."\n";

        $this->depth--;
    }

    function start_ns($parser, $prefix, $uri) {
        #print str_repeat(" ", $this->depth * $this->indent) . "starting: " . $prefix . ":" . $uri . "\n";
        array_push($this->ns_decls, array($prefix,$uri));
    }

    function end_ns($parser, $prefix) {
        #print str_repeat(" ", $this->depth * $this->indent) . "ending: #" . $prefix . "#\n";
    }

    function cdata($parser, $data) {
        #print str_repeat(" ", $this->depth * $this->indent) . "data: #" . $data . "#\n";
        if(!empty($this->in_content)) {
            // handle self-closing tags (case: text node found, need to close element started)
            if (strpos($this->in_content[count($this->in_content)-1], '<') !== false) {
                array_push($this->in_content, ">");
            }
            array_push($this->in_content, $this->xml_escape($data));
        }
    }

    function _default($parser, $data) {
        # when does this gets called?
    }


    function ns_to_prefix($qname) {
        $components = split(":", $qname);
        $name = array_pop($components);

        if(!empty($components)) {
            $ns = join(":",$components);
            foreach($this->ns_contexts as $context) {
                foreach($context as $mapping) {
                    if($mapping[1] == $ns && strlen($mapping[0]) > 0) {
                        return "$mapping[0]:$name";
                    }
                }
            }
        } 
        return $name;
    }

    function xml_escape($string)
    {
             return str_replace(array('&','"',"'",'<','>'), 
                array('&amp;','&quot;','&apos;','&lt;','&gt;'), 
                $string );
    }
}

class AtomServer {

    var $ATOM_CONTENT_TYPE = 'application/atom+xml';
    var $CATEGORIES_CONTENT_TYPE = 'application/atomcat+xml';
    var $INTROSPECTION_CONTENT_TYPE = 'application/atomserv+xml';

    var $ENTRIES_PATH = "posts";
    var $CATEGORIES_PATH = "categories";
    var $MEDIA_PATH = "attachments";
    var $ENTRY_PATH = "post";
    var $MEDIA_SINGLE_PATH = "attachment";

    var $params = array();
    var $script_name = "wp-app.php";
    var $media_content_types = array('image/*','audio/*','video/*');
    var $atom_content_types = array('application/atom+xml');

    var $selectors = array();

    // support for head
    var $do_output = true;

    function AtomServer() {

        $this->script_name = array_pop(explode('/',$_SERVER['SCRIPT_NAME']));

        $this->selectors = array(
            '@/service@' => 
                array('GET' => 'get_service'),
            '@/categories@' =>
                array('GET' => 'get_categories_xml'),
            '@/post/(\d+)@' => 
                array('GET' => 'get_post', 
                        'PUT' => 'put_post', 
                        'DELETE' => 'delete_post'),
            '@/posts/?([^/]+)?@' => 
                array('GET' => 'get_posts', 
                        'POST' => 'create_post'),
            '@/attachments/?(\d+)?@' => 
                array('GET' => 'get_attachment', 
                        'POST' => 'create_attachment'),
            '@/attachment/file/(\d+)@' => 
                array('GET' => 'get_file', 
                        'PUT' => 'put_file', 
                        'DELETE' => 'delete_file'),
            '@/attachment/(\d+)@' => 
                array('GET' => 'get_attachment', 
                        'PUT' => 'put_attachment', 
                        'DELETE' => 'delete_attachment'),
        );
    }

    function handle_request() {

        $path = $_SERVER['PATH_INFO'];
        $method = $_SERVER['REQUEST_METHOD'];

        log_app('REQUEST',"$method $path\n================");

        //$this->process_conditionals();

        // exception case for HEAD (treat exactly as GET, but don't output)
        if($method == 'HEAD') {
            $this->do_output = false;
            $method = 'GET';
        }

        // lame. 
        if(strlen($path) == 0 || $path == '/') {
            $path = '/service';
        }

        // authenticate regardless of the operation and set the current
        // user. each handler will decide if auth is required or not.
        $this->authenticate();

        // dispatch
        foreach($this->selectors as $regex => $funcs) {
            if(preg_match($regex, $path, $matches)) {
                if(isset($funcs[$method])) {
                    array_shift($matches);
                    call_user_func_array(array(&$this,$funcs[$method]), $matches);
                    exit();
                } else {
                    // only allow what we have handlers for...
                    $this->not_allowed(array_keys($funcs));
                }
            }
        }

        // oops, nothing found
        $this->not_found();
    }

    function get_service() {
        log_app('function','get_service()');
        $entries_url = $this->get_entries_url();
        $categories_url = $this->get_categories_url(); 
        $media_url = $this->get_attachments_url();
        $accepted_content_types = join(',',$this->media_content_types);
        $introspection = <<<EOD
<service xmlns="http://purl.org/atom/app#" xmlns:atom="http://www.w3.org/2005/Atom"> 
    <workspace title="WordPress Workspace"> 
        <collection href="$entries_url" title="Posts"> 
        <atom:title>WordPress Posts</atom:title> 
        <accept>entry</accept> 
        <categories href="$categories_url" /> 
        </collection> 
        <collection href="$media_url" title="Media"> 
        <atom:title>WordPress Media</atom:title> 
        <accept>$accepted_content_types</accept> 
        </collection> 
    </workspace> 
</service>

EOD;

        $this->output($introspection, $this->INTROSPECTION_CONTENT_TYPE); 
    }

function get_categories_xml() {
    log_app('function','get_categories_xml()');
    $home = get_bloginfo_rss('home');

    $categories = "";
    $cats = get_categories("hierarchical=0&hide_empty=0");
    foreach ((array) $cats as $cat) {
        $categories .= "    <category term=\"" . attribute_escape($cat->cat_name) .  "\" />\n";
    }
        $output = <<<EOD
<app:categories xmlns:app="http://purl.org/atom/app#"
    xmlns="http://www.w3.org/2005/Atom"
    fixed="yes" scheme="$home">
    $categories
</app:categories>
EOD;
    $this->output($output, $this->CATEGORIES_CONTENT_TYPE); 
}

    /*
     * Create Post (No arguments)
     */
    function create_post() {
        global $blog_id;
        $this->get_accepted_content_type($this->atom_content_types);

        $parser = new AtomParser();
        if(!$parser->parse()) {
            $this->client_error();
        }

        $entry = $parser->entry;

        $publish = (isset($entry->draft) && trim($entry->draft) == 'yes') ? false : true;

        $cap = ($publish) ? 'publish_posts' : 'edit_posts';

        if(!current_user_can($cap))
            $this->auth_required('Sorry, you do not have the right to edit/publish new posts.');

        $blog_ID = (int ) $blog_id;
        $post_status = ($publish) ? 'publish' : 'draft';
        $post_author = (int) $user->ID;
        $post_title = $entry->title;
        $post_content = $entry->content;
        $post_excerpt = $entry->summary;
        $post_date = current_time('mysql');
        $post_date_gmt = current_time('mysql', 1);

        $post_data = compact('blog_ID', 'post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_title', 'post_category', 'post_status', 'post_excerpt');

        log_app('Inserting Post. Data:', print_r($post_data,true));

        $postID = wp_insert_post($post_data);

        if (!$postID) {
            $this->internal_error('Sorry, your entry could not be posted. Something wrong happened.');
        }

        $output = $this->get_entry($postID);

        log_app('function',"create_post($postID)");
        $this->created($postID, $output);
    }

    function get_post($postID) {

        global $entry;
        $this->set_current_entry($postID);
        $output = $this->get_entry($postID);
        log_app('function',"get_post($postID)");
        $this->output($output);

    }

    function put_post($postID) {

        // checked for valid content-types (atom+xml)
        // quick check and exit
        $this->get_accepted_content_type($this->atom_content_types);

        $parser = new AtomParser();
        if(!$parser->parse()) {
            $this->bad_request();
        }

        $parsed = $parser->entry;

        // check for not found
        global $entry;
        $entry = $GLOBALS['entry'];
        $this->set_current_entry($postID);
        $this->escape($GLOBALS['entry']);

        if(!current_user_can('edit_post', $entry['ID']))
            $this->auth_required('Sorry, you do not have the right to edit this post.');

        $publish = (isset($parsed->draft) && trim($parsed->draft) == 'yes') ? false : true;

        extract($entry);

        $post_title = $parsed->title;
        $post_content = $parsed->content;
        $post_excerpt = $parsed->summary;

        // let's not go backwards and make something draft again.
        if(!$publish && $post_status == 'draft') {
            $post_status = ($publish) ? 'publish' : 'draft';
        }

        $postdata = compact('ID', 'post_content', 'post_title', 'post_category', 'post_status', 'post_excerpt');