WordPress.org

Plugin Directory

Changeset 493326


Ignore:
Timestamp:
01/21/12 22:01:12 (2 years ago)
Author:
maxcutler
Message:

Version 0.6 release.

Location:
xml-rpc-modernization/trunk
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • xml-rpc-modernization/trunk/readme.txt

    r493325 r493326  
    4343== Changelog == 
    4444 
     45= 0.6 = 
     46* Revised implementations of many methods. 
     47* Added `fields` parameter to wp.getUser and wp.getUsers. 
     48* Updated method docstrings. 
     49* Moved new XML-RPC server class implementation to its own file. 
     50* Added new wp.getUserInfo method. 
     51* Added `group_by_taxonomy` parameter to wp.getPostTerms. 
     52 
    4553= 0.5 = 
    46 Initial release containing most of the anticipated methods. 
     54* Initial release containing most of the anticipated methods. 
  • xml-rpc-modernization/trunk/wp-xmlrpc-modernization.php

    r493325 r493326  
    44 * Plugin Name: wp-xmlrpc-modernization 
    55 * Description: This plugin extends the basic XML-RPC API exposed by WordPress. Derived from GSoC '11 project. 
    6  * Version: 0.5 
     6 * Version: 0.6 
    77 * Author: Max Cutler 
    88 * Author URI: http://www.maxcutler.com 
     
    1010*/ 
    1111 
    12 include_once(ABSPATH . WPINC . '/class-IXR.php'); 
    13 include_once(ABSPATH . WPINC . '/class-wp-xmlrpc-server.php'); 
    14  
    1512add_filter( 'wp_xmlrpc_server_class', 'replace_xmlrpc_server_class' ); 
    1613 
    1714function replace_xmlrpc_server_class( $class_name ) { 
    1815    // only replace the default XML-RPC class if another plug-in hasn't already changed it 
    19     if ( $class_name === 'wp_xmlrpc_server' ) 
     16    if ( $class_name === 'wp_xmlrpc_server' ) { 
     17        include_once( 'class-wp-xmlrpc-server-ext.php' ); 
    2018        return 'wp_xmlrpc_server_ext'; 
    21     else 
     19    } else { 
    2220        return $class_name; 
    23 } 
    24  
    25 class wp_xmlrpc_server_ext extends wp_xmlrpc_server { 
    26  
    27     function __construct() { 
    28         // hook filter to add the new methods after the existing ones are added in the parent constructor 
    29         add_filter( 'xmlrpc_methods' , array( &$this, 'xmlrpc_methods' ) ); 
    30  
    31         parent::__construct(); 
    32     } 
    33  
    34     function xmlrpc_methods ( $methods ) { 
    35         $new_methods = array(); 
    36  
    37         // user management 
    38         $new_methods['wp.newUser']          = array( &$this, 'wp_newUser' ); 
    39         $new_methods['wp.editUser']         = array( &$this, 'wp_editUser' ); 
    40         $new_methods['wp.deleteUser']       = array( &$this, 'wp_deleteUser' ); 
    41         $new_methods['wp.getUser']          = array( &$this, 'wp_getUser' ); 
    42         $new_methods['wp.getUsers']         = array( &$this, 'wp_getUsers' ); 
    43  
    44         // custom post type management 
    45         $new_methods['wp.getPost']          = array( &$this, 'wp_getPost' ); 
    46         $new_methods['wp.getPosts']         = array( &$this, 'wp_getPosts' ); 
    47         $new_methods['wp.getPostTerms']     = array( &$this, 'wp_getPostTerms' ); 
    48         $new_methods['wp.setPostTerms']     = array( &$this, 'wp_setPostTerms' ); 
    49         $new_methods['wp.getPostType']      = array( &$this, 'wp_getPostType' ); 
    50         $new_methods['wp.getPostTypes']     = array( &$this, 'wp_getPostTypes' ); 
    51  
    52         // custom taxonomy management 
    53         $new_methods['wp.newTerm']          = array( &$this, 'wp_newTerm' ); 
    54         $new_methods['wp.editTerm']         = array( &$this, 'wp_editTerm' ); 
    55         $new_methods['wp.deleteTerm']       = array( &$this, 'wp_deleteTerm' ); 
    56         $new_methods['wp.getTerm']          = array( &$this, 'wp_getTerm' ); 
    57         $new_methods['wp.getTerms']         = array( &$this, 'wp_getTerms' ); 
    58         $new_methods['wp.getTaxonomy']      = array( &$this, 'wp_getTaxonomy' ); 
    59         $new_methods['wp.getTaxonomies']    = array( &$this, 'wp_getTaxonomies' ); 
    60  
    61         // array_merge will take the values defined in later arguments, so 
    62         // the plugin will not overwrite any methods defined by WP core 
    63         // (i.e., plugin will be forward-compatible with future releases of WordPress 
    64         //  that include these methods built-in) 
    65         return array_merge( $new_methods, $methods ); 
    66     } 
    67  
    68     /** 
    69      * Prepares user data for return in an XML-RPC object 
    70      * 
    71      * @param obj $user The unprepared WP_User object 
    72      * @return array The prepared user data 
    73      */ 
    74     function prepare_user( $user ) { 
    75         $contact_methods = _wp_get_user_contactmethods(); 
    76  
    77         $user_contacts = array(); 
    78         foreach( $contact_methods as $key => $value ) { 
    79             $user_contacts[ $key ] = $user->$key; 
    80         } 
    81  
    82         $_user = array( 
    83             'user_id'           => $user->ID, 
    84             'username'          => $user->user_login, 
    85             'first_name'        => $user->user_firstname, 
    86             'last_name'         => $user->user_lastname, 
    87             'registered'        => new IXR_Date( mysql2date('Ymd\TH:i:s', $user->user_registered, false) ), 
    88             'bio'               => $user->user_description, 
    89             'email'             => $user->user_email, 
    90             'nickname'          => $user->nickname, 
    91             'nicename'          => $user->user_nicename, 
    92             'url'               => $user->user_url, 
    93             'display_name'      => $user->display_name, 
    94             'capabilities'      => $user->wp_capabilities, 
    95             'user_level'        => $user->wp_user_level, 
    96             'user_contacts'     => $user_contacts 
    97         ); 
    98  
    99         return apply_filters( 'xmlrpc_prepare_user', $_user, $user ); 
    100     } 
    101  
    102     /** 
    103      * Prepares post data for return in an XML-RPC object 
    104      * 
    105      * @param array $post The unprepared post data 
    106      * @param array $fields The subset of post fields to return 
    107      * @return array The prepared post data 
    108      */ 
    109     function prepare_post( $post, $fields ) { 
    110         // pre-calculate conceptual group in_array searches 
    111         $all_post_fields = in_array( 'post', $fields ); 
    112         $all_taxonomy_fields = in_array( 'taxonomies', $fields ); 
    113  
    114         // holds the data for this post. built up based on $fields 
    115         $_post = array( 'postid' => $post['ID'] ); 
    116  
    117         if ( $all_post_fields || in_array( 'title', $fields ) ) 
    118             $_post['title'] = $post['post_title']; 
    119  
    120         if ( $all_post_fields || in_array( 'post_date', $fields ) ) 
    121             $_post['post_date'] = new IXR_Date(mysql2date( 'Ymd\TH:i:s', $post['post_date'], false )); 
    122  
    123         if ( $all_post_fields || in_array( 'post_date_gmt', $fields ) ) 
    124             $_post['post_date_gmt'] = new IXR_Date(mysql2date( 'Ymd\TH:i:s', $post['post_date_gmt'], false )); 
    125  
    126         if ( $all_post_fields || in_array( 'post_modified', $fields ) ) 
    127             $_post['post_modified'] = new IXR_Date(mysql2date( 'Ymd\TH:i:s', $post['post_modified'], false )); 
    128  
    129         if ( $all_post_fields || in_array( 'post_modified_gmt', $fields ) ) 
    130             $_post['post_modified_gmt'] = new IXR_Date(mysql2date( 'Ymd\TH:i:s', $post['post_modified_gmt'], false )); 
    131  
    132         if ( $all_post_fields || in_array( 'post_status', $fields ) ) { 
    133             // Consider future posts as published 
    134             if ( $post['post_status'] === 'future' ) 
    135                 $_post['post_status'] = 'publish'; 
    136             else 
    137                 $_post['post_status'] = $post['post_status']; 
    138         } 
    139  
    140         if ( $all_post_fields || in_array( 'post_type', $fields ) ) 
    141             $_post['post_type'] = $post['post_type']; 
    142  
    143         if ( $all_post_fields || in_array( 'post_format', $fields ) ) { 
    144             $post_format = get_post_format( $post['ID'] ); 
    145             if ( empty( $post_format ) ) 
    146                 $post_format = 'standard'; 
    147             $_post['post_format'] = $post_format; 
    148         } 
    149  
    150         if ( $all_post_fields || in_array( 'wp_slug', $fields ) ) 
    151             $_post['wp_slug'] = $post['post_name']; 
    152  
    153         if ( $all_post_fields || in_array( 'link', $fields ) ) 
    154             $_post['link'] = post_permalink( $post['ID'] ); 
    155  
    156         if ( $all_post_fields || in_array( 'permaLink', $fields ) ) 
    157             $_post['permaLink'] = post_permalink( $post['ID'] ); 
    158  
    159         if ( $all_post_fields || in_array( 'userid', $fields ) ) 
    160             $_post['userid'] = $post['post_author']; 
    161  
    162         if ( $all_post_fields || in_array( 'wp_author_id', $fields ) ) 
    163             $_post['wp_author_id'] = $post['post_author']; 
    164  
    165         if ( $all_post_fields || in_array( 'mt_allow_comments', $fields ) ) 
    166             $_post['mt_allow_comments'] = $post['comment_status']; 
    167  
    168         if ( $all_post_fields || in_array( 'mt_allow_pings', $fields ) ) 
    169             $_post['mt_allow_pings'] = $post['ping_status']; 
    170  
    171         if ( $all_post_fields || in_array( 'sticky', $fields ) ) { 
    172             $sticky = null; 
    173             if( $post['post_type'] == 'post' ) { 
    174                 $sticky = false; 
    175                 if ( is_sticky( $post['ID'] ) ) 
    176                     $sticky = true; 
    177             } 
    178             $_post['sticky'] = $sticky; 
    179         } 
    180  
    181         if ( $all_post_fields || in_array( 'wp_password', $fields ) ) 
    182             $_post['wp_password'] = $post['post_password']; 
    183  
    184         if ( $all_post_fields || in_array( 'mt_excerpt', $fields ) ) 
    185             $_post['mt_excerpt'] = $post['post_excerpt']; 
    186  
    187         if ( $all_post_fields || in_array( 'description', $fields ) ) { 
    188             $post_content = get_extended( $post['post_content'] ); 
    189             $_post['description'] = $post_content['main']; 
    190             $_post['mt_text_more'] = $post_content['extended']; 
    191         } 
    192  
    193         if ( $all_taxonomy_fields || in_array( 'terms', $fields ) ) { 
    194             $post_type_taxonomies = get_object_taxonomies( $post['post_type'] , 'names'); 
    195             $_post['terms'] = wp_get_object_terms( $post['ID'], $post_type_taxonomies );; 
    196         } 
    197  
    198         // backward compatiblity 
    199         if ( $all_taxonomy_fields || in_array( 'mt_keywords', $fields ) ) { 
    200             $tagnames = array(); 
    201             $tags = wp_get_post_tags( $post['ID'] ); 
    202             if ( !empty( $tags ) ) { 
    203                 foreach ( $tags as $tag ) 
    204                     $tagnames[] = $tag->name; 
    205                 $tagnames = implode( ', ', $tagnames ); 
    206             } else { 
    207                 $tagnames = ''; 
    208             } 
    209             $_post['mt_keywords'] = $tagnames; 
    210         } 
    211  
    212         // backward compatiblity 
    213         if ( $all_taxonomy_fields || in_array( 'categories', $fields ) ) { 
    214             $categories = array(); 
    215             $catids = wp_get_post_categories( $post['ID'] ); 
    216             foreach($catids as $catid) { 
    217                 $categories[] = get_cat_name($catid); 
    218             } 
    219             $_post['categories'] = $categories; 
    220         } 
    221  
    222         if ( in_array( 'custom_fields', $fields ) ) 
    223             $_post['custom_fields'] = $this->get_custom_fields( $post['ID'] ); 
    224  
    225         if ( in_array( 'enclosure', $fields ) ) { 
    226             $enclosure = array(); 
    227             foreach ( (array) get_post_custom( $post['ID'] ) as $key => $val) { 
    228                 if ($key == 'enclosure') { 
    229                     foreach ( (array) $val as $enc ) { 
    230                         $encdata = split("\n", $enc); 
    231                         $enclosure['url'] = trim(htmlspecialchars($encdata[0])); 
    232                         $enclosure['length'] = (int) trim($encdata[1]); 
    233                         $enclosure['type'] = trim($encdata[2]); 
    234                         break 2; 
    235                     } 
    236                 } 
    237             } 
    238             $_post['enclosure'] = $enclosure; 
    239         } 
    240  
    241         return apply_filters( 'xmlrpc_prepare_post', $_post, $post, $fields ); 
    242     } 
    243  
    244     /** 
    245      * Prepares taxonomy data for return in an XML-RPC object 
    246      * 
    247      * @param array|object $taxonomy The unprepared taxonomy data 
    248      * @return array The prepared taxonomy data 
    249      */ 
    250     function prepare_taxonomy( $taxonomy ) { 
    251         $_taxonomy = (array) $taxonomy; 
    252  
    253         unset( 
    254             $_taxonomy['update_count_callback'] 
    255         ); 
    256  
    257         return apply_filters( 'xmlrpc_prepare_taxonomy', $_taxonomy, $taxonomy ); 
    258     } 
    259  
    260     /** 
    261      * Prepares term data for return in an XML-RPC object 
    262      * 
    263      * @param array $term The unprepared term data 
    264      * @return array The prepared term data 
    265      */ 
    266     function prepare_term( $term ) { 
    267         $_term = (array) $term; 
    268  
    269         return apply_filters( 'xmlrpc_prepare_term', $_term, $term ); 
    270     } 
    271  
    272     /** 
    273      * Prepares post type data for return in an XML-RPC object 
    274      * 
    275      * @param array|object $post_type The unprepared post type data 
    276      * @return array The prepared post type data 
    277      */ 
    278     function prepare_post_type( $post_type ) { 
    279         $_post_type = (array) $post_type; 
    280  
    281         $_post_type['taxonomies'] = get_object_taxonomies( $_post_type['name'] ); 
    282  
    283         return apply_filters( 'xmlrpc_prepare_post_type', $_post_type, $post_type ); 
    284     } 
    285  
    286     /** 
    287      * Create a new user 
    288      * 
    289      * @uses wp_insert_user() 
    290      * @param array $args Method parameters. Contains: 
    291      *  - int     $blog_id 
    292      *  - string  $username 
    293      *  - string  $password 
    294      *  - array     $content_struct. 
    295      *      The $content_struct must contain: 
    296      *      - 'username' 
    297      *      - 'password' 
    298      *      - 'email' 
    299      *      Also, it can optionally contain: 
    300      *      - 'role' 
    301      *      - 'first_name' 
    302      *      - 'last_name' 
    303      *      - 'website' 
    304      *  - boolean $send_mail optional. Defaults to false 
    305      * @return int user_id 
    306      */ 
    307     function wp_newUser( $args ) { 
    308         $this->escape($args); 
    309  
    310         $blog_id        = (int) $args[0]; 
    311         $username       = $args[1]; 
    312         $password       = $args[2]; 
    313         $content_struct = $args[3]; 
    314         $send_mail      = isset( $args[4] ) ? $args[4] : false; 
    315  
    316         if ( ! $user = $this->login( $username, $password ) ) 
    317             return $this->error; 
    318  
    319         do_action( 'xmlrpc_call', 'wp.newUser' ); 
    320  
    321         if ( ! current_user_can( 'create_users' ) ) 
    322             return new IXR_Error( 401, __( 'You are not allowed to create users.' ) ); 
    323  
    324         // this hold all the user data 
    325         $user_data = array(); 
    326  
    327         if( empty ( $content_struct['username'] ) ) 
    328             return new IXR_Error( 403, __( 'Username cannot be empty.' ) ); 
    329         $user_data['user_login'] = $content_struct['username']; 
    330  
    331         if( empty ( $content_struct['password'] ) ) 
    332             return new IXR_Error( 403, __( 'Password cannot be empty.' ) ); 
    333         $user_data['user_pass'] = $content_struct['password']; 
    334  
    335         if( empty ( $content_struct['email'] ) ) 
    336             return new IXR_Error( 403, __( 'Email cannot be empty.' ) ); 
    337  
    338         if( ! is_email( $content_struct['email'] ) ) 
    339             return new IXR_Error( 403, __( 'This email address is not valid.' ) ); 
    340  
    341         if( email_exists( $content_struct['email'] ) ) 
    342             return new IXR_Error( 403, __( 'This email address is already registered.' ) ); 
    343  
    344         $user_data['user_email'] = $content_struct['email']; 
    345  
    346         if( isset ( $content_struct['role'] ) ) { 
    347             if ( get_role( $content_struct['role'] ) === null ) 
    348                 return new IXR_Error( 403, __( 'The role specified is not valid.' ) ); 
    349  
    350             $user_data['role'] = $content_struct['role']; 
    351         } 
    352  
    353         if( isset ( $content_struct['first_name'] ) ) 
    354             $user_data['first_name'] = $content_struct['first_name']; 
    355  
    356         if( isset ( $content_struct['last_name'] ) ) 
    357             $user_data['last_name'] = $content_struct['last_name']; 
    358  
    359         if( isset ( $content_struct['url'] ) ) 
    360             $user_data['user_url'] = $content_struct['url']; 
    361  
    362         $user_id = wp_insert_user( $user_data ); 
    363  
    364         if ( is_wp_error( $user_id ) ) 
    365             return new IXR_Error( 500, $user_id->get_error_message() ); 
    366  
    367         if ( ! $user_id ) 
    368             return new IXR_Error( 500, __( 'Sorry, the new user failed.' ) ); 
    369  
    370         if ( $send_mail ) { 
    371             wp_new_user_notification( $user_id, $user_data['user_pass'] ); 
    372         } 
    373  
    374         return $user_id; 
    375     } 
    376  
    377     /** 
    378      * Edit a new user 
    379      * 
    380      * @uses wp_update_user() 
    381      * @param array $args Method parameters. Contains: 
    382      *  - int     $blog_id 
    383      *  - string  $username 
    384      *  - string  $password 
    385      *  - int     $user_id 
    386      *  - array   $content_struct. 
    387      *      It can optionally contain: 
    388      *      - 'email' 
    389      *      - 'first_name' 
    390      *      - 'last_name' 
    391      *      - 'website' 
    392      *      - 'role' 
    393      *      - 'nickname' 
    394      *      - 'usernicename' 
    395      *      - 'bio' 
    396      *      - 'usercontacts' 
    397      *      - 'password' 
    398      *  - boolean $send_mail optional. Defaults to false 
    399      * @return int user_id 
    400      */ 
    401     function wp_editUser( $args ) { 
    402         $this->escape( $args ); 
    403  
    404         $blog_id        = (int) $args[0]; 
    405         $username       = $args[1]; 
    406         $password       = $args[2]; 
    407         $user_id        = (int) $args[3]; 
    408         $content_struct = $args[4]; 
    409  
    410         if ( ! $user = $this->login( $username, $password ) ) 
    411             return $this->error; 
    412  
    413         do_action( 'xmlrpc_call', 'wp.editUser' ); 
    414  
    415         $user_info = get_userdata( $user_id ); 
    416  
    417         if( ! $user_info ) 
    418             return new IXR_Error( 404, __( 'Invalid user ID.' ) ); 
    419  
    420         if( ! ( $user_id == $user->ID || current_user_can( 'edit_users' ) ) ) 
    421             return new IXR_Error(401, __( 'Sorry, you cannot edit this user.' ) ); 
    422  
    423         // holds data of the user 
    424         $user_data = array(); 
    425         $user_data['ID'] = $user_id; 
    426  
    427         if ( isset( $content_struct['username'] ) && $content_struct['username'] !== $user_info->user_login ) 
    428             return new IXR_Error( 401, __( 'Username cannot be changed.' ) ); 
    429  
    430         if ( isset( $content_struct['email'] ) ) { 
    431             if( ! is_email( $content_struct['email'] ) ) 
    432                 return new IXR_Error( 403, __( 'This email address is not valid.' ) ); 
    433  
    434             // check whether it is already registered 
    435             if( $content_struct['email'] !== $user_info->user_email && email_exists( $content_struct['email'] ) ) 
    436                 return new IXR_Error( 403, __( 'This email address is already registered.' ) ); 
    437  
    438             $user_data['user_email'] = $content_struct['email']; 
    439         } 
    440  
    441         if( isset ( $content_struct['role'] ) ) { 
    442             if ( ! current_user_can( 'edit_users' ) ) 
    443                 return new IXR_Error( 401, __( 'You are not allowed to change roles for this user.' ) ); 
    444  
    445             if ( get_role( $content_struct['role'] ) === null ) 
    446                 return new IXR_Error( 403, __( 'The role specified is not valid' ) ); 
    447  
    448             $user_data['role'] = $content_struct['role']; 
    449         } 
    450  
    451         // only set the user details if it was given 
    452         if ( isset( $content_struct['first_name'] ) ) 
    453             $user_data['first_name'] = $content_struct['first_name']; 
    454  
    455         if ( isset( $content_struct['last_name'] ) ) 
    456             $user_data['last_name'] = $content_struct['last_name']; 
    457  
    458         if ( isset( $content_struct['website'] ) ) 
    459             $user_data['user_url'] = $content_struct['url']; 
    460  
    461         if ( isset( $content_struct['nickname'] ) ) 
    462             $user_data['nickname'] = $content_struct['nickname']; 
    463  
    464         if ( isset( $content_struct['usernicename'] ) ) 
    465             $user_data['user_nicename'] = $content_struct['nicename']; 
    466  
    467         if ( isset( $content_struct['bio'] ) ) 
    468             $user_data['description'] = $content_struct['bio']; 
    469  
    470         if( isset ( $content_struct['user_contacts'] ) ) { 
    471             $user_contacts = _wp_get_user_contactmethods( $user_data ); 
    472             foreach( $content_struct['user_contacts'] as $key => $value ) { 
    473                 if( ! array_key_exists( $key, $user_contacts ) ) 
    474                     return new IXR_Error( 403, __( 'One of the contact method specified is not valid' ) ); 
    475  
    476                 $user_data[ $key ] = $value; 
    477             } 
    478         } 
    479  
    480         if( isset ( $content_struct['password'] ) ) 
    481             $user_data['user_pass'] = $content_struct['password']; 
    482  
    483         $result = wp_update_user( $user_data ); 
    484  
    485         if ( is_wp_error( $result ) ) 
    486             return new IXR_Error( 500, $result->get_error_message() ); 
    487  
    488         if ( ! $result ) 
    489             return new IXR_Error( 500, __( 'Sorry, the user cannot be updated. Something wrong happened.' ) ); 
    490  
    491         return $result; 
    492     } 
    493  
    494     /** 
    495      * Delete a user 
    496      * 
    497      * @uses wp_delete_user() 
    498      * @param array $args Method parameters. Contains: 
    499      *  - int     $blog_id 
    500      *  - string  $username 
    501      *  - string  $password 
    502      *  - int     $user_id 
    503      * @return True when user is deleted. 
    504      */ 
    505     function wp_deleteUser( $args ) { 
    506         $this->escape( $args ); 
    507  
    508         $blog_id    = (int) $args[0]; 
    509         $username   = $args[1]; 
    510         $password   = $args[2]; 
    511         $user_id    = (int) $args[3]; 
    512  
    513         if( ! $user = $this->login( $username, $password ) ) 
    514             return $this->error; 
    515  
    516         do_action( 'xmlrpc_call', 'wp.deleteUser' ); 
    517  
    518         if( ! current_user_can( 'delete_users' ) ) 
    519             return new IXR_Error( 401, __( 'You are not allowed to delete users.' ) ); 
    520  
    521         if( ! get_userdata( $user_id ) ) 
    522             return new IXR_Error( 404, __('Invalid user ID.' ) ); 
    523  
    524         if( $user->ID == $user_id ) 
    525             return new IXR_Error( 401, __( 'You cannot delete yourself.' ) ); 
    526  
    527         return wp_delete_user( $user_id ); 
    528     } 
    529  
    530     /** 
    531      * Retrieve  user 
    532      * 
    533      * @uses get_userdata() 
    534      * @param array $args Method parameters. Contains: 
    535      *  - int     $blog_id 
    536      *  - string  $username 
    537      *  - string  $password 
    538      *  - int     $user_id 
    539      * @return array contains: 
    540      *  - 'user_login' 
    541      *  - 'user_firstname' 
    542      *  - 'user_lastname' 
    543      *  - 'user_registered' 
    544      *  - 'user_description' 
    545      *  - 'user_email' 
    546      *  - 'nickname' 
    547      *  - 'user_nicename' 
    548      *  - 'user_url' 
    549      *  - 'display_name' 
    550      *  - 'usercontacts' 
    551      */ 
    552     function wp_getUser( $args ) { 
    553         $this->escape( $args ); 
    554  
    555         $blog_id    = (int) $args[0]; 
    556         $username   = $args[1]; 
    557         $password   = $args[2]; 
    558         $user_id    = (int) $args[3]; 
    559  
    560         if ( ! $user = $this->login( $username, $password ) ) 
    561             return $this->error; 
    562  
    563         do_action( 'xmlrpc_call', 'wp.getUser' ); 
    564  
    565         $user_data = get_userdata( $user_id ); 
    566  
    567         if( ! $user_data ) 
    568             return new IXR_Error(404, __('Invalid user ID')); 
    569  
    570         if( ! ( $user_id == $user->ID || current_user_can( 'edit_users' ) )) 
    571             return new IXR_Error( 401, __( 'Sorry, you cannot edit users.' ) ); 
    572  
    573         $user = $this->prepare_user( $user_data ); 
    574  
    575         return $user; 
    576     } 
    577  
    578     /** 
    579      * Retrieve  users 
    580      * 
    581      * @uses get_users() 
    582      * @param array $args Method parameters. Contains: 
    583      *  - int     $blog_id 
    584      *  - string  $username 
    585      *  - string  $password 
    586      *  - array   $filter optional 
    587      * @return array contatins: 
    588      *  - 'ID' 
    589      *  - 'user_login' 
    590      *  - 'user_registered' 
    591      *  - 'user_email' 
    592      *  - 'user_url' 
    593      *  - 'display_name' 
    594      *  - 'user_nicename' 
    595      */ 
    596     function wp_getUsers( $args ) { 
    597         $this->escape( $args ); 
    598  
    599         $blog_id    = (int) $args[0]; 
    600         $username   = $args[1]; 
    601         $password   = $args[2]; 
    602         $filter     = isset( $args[3] ) ? $args[3] : array(); 
    603  
    604         if ( ! $user = $this->login( $username, $password ) ) 
    605             return $this->error; 
    606  
    607         do_action( 'xmlrpc_call', 'wp.getUsers' ); 
    608  
    609         if( ! current_user_can( 'edit_users' )) 
    610             return new IXR_Error( 401, __( 'Sorry, you cannot edit users.' ) ); 
    611  
    612         $query = array(); 
    613  
    614         // only retrieve IDs since wp_getUser will ignore anything else 
    615         $query['fields'] = array( 'ID' ); 
    616  
    617         $query['number'] = ( isset( $filter['number'] ) ) ? absint( $filter['number'] ) : 50; 
    618         $query['offset'] = ( isset( $filter['offset'] ) ) ? absint( $filter['offset'] ) : 0; 
    619  
    620         if ( isset( $filter['role'] ) ) { 
    621             global $wp_roles; 
    622  
    623             if( ! isset ( $wp_roles ) ) 
    624                 $wp_roles = new WP_Roles (); 
    625  
    626             if( ! array_key_exists( $filter['role'], $wp_roles->get_names() ) ) 
    627                 return new IXR_Error( 403, __( 'The role specified is not valid' ) ); 
    628  
    629             $query['role'] = $filter['role']; 
    630         } 
    631  
    632         $users = get_users( $query ); 
    633  
    634         $_users = array(); 
    635         foreach ( $users as $user_data ) { 
    636             $_users[] = $this->prepare_user( get_userdata( $user_data->ID ) ); 
    637         } 
    638  
    639         return $_users; 
    640     } 
    641  
    642     /** 
    643      * Retrieve  post 
    644      * 
    645      * @uses wp_get_single_post() 
    646      * @param array $args Method parameters. Contains: 
    647      *  - int     $post_id 
    648      *  - string  $username 
    649      *  - string  $password 
    650      * @return array contains: 
    651      *  - 'postid' 
    652      *  - 'title' 
    653      *  - 'description' 
    654      *  - 'mt_excerpt' 
    655      *  - 'post_status' 
    656      *  - 'post_type' 
    657      *  - 'wp_slug' 
    658      *  - 'wp_password' 
    659      *  - 'wp_page_order' 
    660      *  - 'wp_page_parent_id' 
    661      *  - 'wp_author_id' 
    662      *  - 'mt_allow_comments' 
    663      *  - 'mt_allow_pings' 
    664      *  - 'dateCreated' 
    665      *  - 'date_created_gmt' 
    666      *  - 'userid' 
    667      *  - 'sticky' 
    668      *  - 'custom_fields' 
    669      *  - 'terms' 
    670      *  - 'link' 
    671      *  - 'permaLink' 
    672      *  - 'categories' 
    673      *  - 'mt_keywords' 
    674      *  - 'wp_post_format' 
    675      */ 
    676     function wp_getPost( $args ) { 
    677         $this->escape( $args ); 
    678  
    679         $blog_id            = (int) $args[0]; 
    680         $username           = $args[1]; 
    681         $password           = $args[2]; 
    682         $post_id            = (int) $args[3]; 
    683  
    684         if ( isset( $args[4] ) ) 
    685             $fields = $args[4]; 
    686         else 
    687             $fields = array( 'post', 'taxonomies', 'custom_fields' ); 
    688  
    689         if ( ! $user = $this->login( $username, $password ) ) 
    690             return $this->error; 
    691  
    692         $post = wp_get_single_post( $post_id, ARRAY_A ); 
    693  
    694         if ( empty( $post["ID"] ) ) 
    695             return new IXR_Error( 404, __( 'Invalid post ID.' ) ); 
    696  
    697         $post_type = get_post_type_object( $post['post_type'] ); 
    698         if( ! current_user_can( $post_type->cap->edit_posts, $post_id ) ) 
    699             return new IXR_Error( 401, __( 'Sorry, you cannot edit this post.' )); 
    700  
    701         return $this->prepare_post( $post, $fields ); 
    702     } 
    703  
    704     /** 
    705      * Retrieve posts. 
    706      * 
    707      * Besides the common blog_id, username, and password arguments, it takes 
    708      * a filter array and a fields array. 
    709      * 
    710      * Accepted 'filter' keys are 'post_type', 'post_status', 'numberposts', 'offset', 
    711      * 'orderby', and 'order'. 
    712      * 
    713      * The 'fields' array specifies which post fields will be included in the response. 
    714      * Values can be either conceptual groups ('post', 'taxonomies', 'custom_fields') 
    715      * or specific field names. By default, all fields are returned. 
    716      * 
    717      * @uses wp_get_recent_posts() 
    718      * @param array $args Method parameters. Contains: 
    719      *  - int     $blog_id 
    720      *  - string  $username 
    721      *  - string  $password 
    722      *  - array   $filter optional 
    723      *  - array   $fields optional 
    724      * @return array. Contains a collection of posts. 
    725      */ 
    726     function wp_getPosts( $args ) { 
    727         $this->escape( $args ); 
    728  
    729         $blog_ID    = (int) $args[0]; 
    730         $username   = $args[1]; 
    731         $password   = $args[2]; 
    732  
    733         if ( isset( $args[3] ) ) 
    734             $filter = $args[3]; 
    735         else 
    736             $filter = array(); 
    737  
    738         if ( isset( $args[4] ) ) 
    739             $fields = $args[4]; 
    740         else 
    741             $fields = array( 'post', 'taxonomies', 'custom_fields' ); 
    742  
    743         if ( !$user = $this->login( $username, $password ) ) 
    744             return $this->error; 
    745  
    746         $query = array(); 
    747  
    748         if ( isset( $filter['post_type'] ) ) { 
    749             $post_type = get_post_type_object( $filter['post_type'] ); 
    750             if( !( (bool)$post_type ) ) 
    751                 return new IXR_Error( 403, __( 'The post type specified is not valid' ) ); 
    752  
    753             if( ! current_user_can( $post_type->cap->edit_posts ) ) 
    754                 return new IXR_Error( 401, __( 'Sorry, you are not allowed to edit posts in this post type' )); 
    755             $query['post_type'] = $filter['post_type']; 
    756         } 
    757  
    758         if ( isset( $filter['post_status'] ) ) { 
    759             $query['post_status'] = $filter['post_status']; 
    760         } 
    761  
    762         if ( isset ( $filter['numberposts'] ) ) { 
    763             $query['numberposts'] = absint( $filter['numberposts'] ); 
    764         } 
    765  
    766         if ( isset ( $filter['offset'] ) ) { 
    767             $query['offset'] = absint( $filter['offset'] ); 
    768         } 
    769  
    770         if ( isset ( $filter['orderby'] ) ) { 
    771             $query['orderby'] = $filter['orderby']; 
    772  
    773             if ( isset ( $filter['order'] ) ) { 
    774                 $query['order'] = $filter['order']; 
    775             } 
    776         } 
    777  
    778         do_action('xmlrpc_call', 'wp.getPosts'); 
    779  
    780         $posts_list = wp_get_recent_posts( $query ); 
    781  
    782         if ( !$posts_list ) 
    783             return array( ); 
    784  
    785         // holds all the posts data 
    786         $struct = array(); 
    787  
    788         foreach ( $posts_list as $post ) { 
    789             $post_type = get_post_type_object( $post['post_type'] ); 
    790             if( !current_user_can( $post_type->cap->edit_posts, $post['ID'] ) ) 
    791                 continue; 
    792  
    793             $struct[] = $this->prepare_post( $post, $fields ); 
    794         } 
    795  
    796         return $struct; 
    797     } 
    798  
    799     /** 
    800      * Retrieve post terms 
    801      * 
    802      * @uses wp_get_object_terms() 
    803      * @param array $args Method parameters. Contains: 
    804      *  - int     $blog_id 
    805      *  - string  $username 
    806      *  - string  $password 
    807      *  - int     $post_id 
    808      * @return array term data 
    809      */ 
    810     function wp_getPostTerms( $args ) { 
    811         $this->escape( $args ); 
    812  
    813         $blog_id            = (int) $args[0]; 
    814         $username           = $args[1]; 
    815         $password           = $args[2]; 
    816         $post_id            = (int) $args[3]; 
    817  
    818         if ( ! $user = $this->login( $username, $password ) ) 
    819             return $this->error; 
    820  
    821         do_action( 'xmlrpc_call', 'wp.getPostTerms' ); 
    822  
    823         $post = wp_get_single_post( $post_id, ARRAY_A ); 
    824         if ( empty( $post['ID'] ) ) 
    825             return new IXR_Error( 404, __( 'Invalid post ID.' ) ); 
    826  
    827         $post_type = get_post_type_object( $post['post_type'] ); 
    828  
    829         if( ! current_user_can( $post_type->cap->edit_post , $post_id ) ) 
    830             return new IXR_Error( 401, __( 'Sorry, you are not allowed to edit this post.' ) ); 
    831  
    832         $taxonomies = get_taxonomies( '' ); 
    833  
    834         $terms = wp_get_object_terms( $post_id , $taxonomies ); 
    835  
    836         if ( is_wp_error( $terms ) ) 
    837             return new IXR_Error( 500 , $terms->get_error_message() ); 
    838  
    839         $struct = array(); 
    840  
    841         foreach ( $terms as $term ) { 
    842             $struct[] = $this->prepare_term( $term ); 
    843         } 
    844  
    845         return $struct; 
    846     } 
    847  
    848     /** 
    849      * Set post terms 
    850      * 
    851      * @uses wp_set_object_terms() 
    852      * @param array $args Method parameters. Contains: 
    853      *  - int     $blog_id 
    854      *  - string  $username 
    855      *  - string  $password 
    856      *  - int     $post_id 
    857      *  - array   $content_struct contains term_ids with taxonomy as keys 
    858      *  - bool    $append 
    859      * @return boolean true 
    860      */ 
    861     function wp_setPostTerms( $args ) { 
    862         $this->escape($args); 
    863  
    864         $blog_id            = (int) $args[0]; 
    865         $username           = $args[1]; 
    866         $password           = $args[2]; 
    867         $post_ID            = (int) $args[3]; 
    868         $content_struct     = $args[4]; 
    869         $append             = $args[5] ? true : false; 
    870  
    871         if ( ! $user = $this->login( $username, $password ) ) 
    872             return $this->error; 
    873  
    874         do_action( 'xmlrpc_call', 'wp.setPostTerms' ); 
    875  
    876         $post = wp_get_single_post( $post_ID, ARRAY_A ); 
    877         if ( empty( $post['ID'] ) ) 
    878             return new IXR_Error( 404, __( 'Invalid post ID.' ) ); 
    879  
    880         $post_type = get_post_type_object( $post['post_type'] ); 
    881  
    882         if( ! current_user_can( $post_type->cap->edit_post , $post_ID ) ) 
    883             return new IXR_Error( 401, __( 'Sorry, You are not allowed to edit this post.' ) ); 
    884  
    885         $post_type_taxonomies = get_object_taxonomies( $post['post_type'] ); 
    886  
    887         $taxonomies = array_keys( $content_struct ); 
    888  
    889         // validating term ids 
    890         foreach( $taxonomies as $taxonomy ) { 
    891             if( ! in_array( $taxonomy , $post_type_taxonomies ) ) 
    892                 return new IXR_Error( 401, __( 'Sorry, one of the given taxonomy is not supported by the post type.' ) ); 
    893  
    894             $term_ids = $content_struct[$taxonomy]; 
    895             foreach ( $term_ids as $term_id ) { 
    896  
    897                 $term = get_term( $term_id, $taxonomy ); 
    898  
    899                 if ( is_wp_error( $term ) ) 
    900                     return new IXR_Error( 500, $term->get_error_message() ); 
    901  
    902                 if ( ! $term ) 
    903                     return new IXR_Error( 403, __( 'Invalid term ID' ) ); 
    904             } 
    905         } 
    906  
    907         foreach( $taxonomies as $taxonomy ) { 
    908             $term_ids = $content_struct[ $taxonomy ]; 
    909             $term_ids = array_map( 'intval', $term_ids ); 
    910             $term_ids = array_unique( $term_ids ); 
    911             wp_set_object_terms( $post_ID , $term_ids, $taxonomy , $append); 
    912         } 
    913  
    914         return true; 
    915     } 
    916  
    917     /** 
    918      * Retrieves a post type 
    919      * 
    920      * @uses get_post_type_object() 
    921      * @param array $args Method parameters. Contains: 
    922      *  - int     $blog_id 
    923      *  - string  $username 
    924      *  - string  $password 
    925      *  - string  $post_type_name 
    926      * @return array contains: 
    927      *  - 'labels' 
    928      *  - 'description' 
    929      *  - 'capability_type' 
    930      *  - 'cap' 
    931      *  - 'map_meta_cap' 
    932      *  - 'hierarchical' 
    933      *  - 'menu_position' 
    934      *  - 'taxonomies' 
    935      */ 
    936     function wp_getPostType( $args ) { 
    937         $this->escape( $args ); 
    938  
    939         $blog_id        = (int) $args[0]; 
    940         $username       = $args[1]; 
    941         $password       = $args[2]; 
    942         $post_type_name = $args[3]; 
    943  
    944         if ( !$user = $this->login( $username, $password ) ) 
    945             return $this->error; 
    946  
    947         do_action( 'xmlrpc_call', 'wp.getPostType' ); 
    948  
    949         if( ! post_type_exists( $post_type_name ) ) 
    950             return new IXR_Error( 403, __( 'Invalid post type.' ) ); 
    951  
    952         $post_type = get_post_type_object( $post_type_name ); 
    953  
    954         if( ! current_user_can( $post_type->cap->edit_posts ) ) 
    955             return new IXR_Error( 401, __( 'Sorry, you are not allowed to edit this post type.' ) ); 
    956  
    957         return $this->prepare_post_type( $post_type ); 
    958     } 
    959  
    960     /** 
    961      * Retrieves a post types 
    962      * 
    963      * @uses get_post_types() 
    964      * @param array $args Method parameters. Contains: 
    965      *  - int     $blog_id 
    966      *  - string  $username 
    967      *  - string  $password 
    968      * @return array 
    969      */ 
    970     function wp_getPostTypes( $args ) { 
    971         $this->escape( $args ); 
    972  
    973         $blog_id            = (int) $args[0]; 
    974         $username           = $args[1]; 
    975         $password           = $args[2]; 
    976  
    977         if ( ! $user = $this->login( $username, $password ) ) 
    978             return $this->error; 
    979  
    980         do_action( 'xmlrpc_call', 'wp.getPostTypes' ); 
    981  
    982         $post_types = get_post_types( '', 'objects' ); 
    983  
    984         $struct = array(); 
    985  
    986         foreach( $post_types as $post_type ) { 
    987             if( ! current_user_can( $post_type->cap->edit_posts ) ) 
    988                 continue; 
    989  
    990             $struct[$post_type->name] = $this->prepare_post_type( $post_type ); 
    991         } 
    992  
    993         return $struct; 
    994     } 
    995  
    996     /** 
    997      * Create a new term 
    998      * 
    999      * @uses wp_insert_term() 
    1000      * @param array $args Method parameters. Contains: 
    1001      *  - int     $blog_id 
    1002      *  - string  $username 
    1003      *  - string  $password 
    1004      *  - array   $content_struct. 
    1005      *      The $content_struct must contain: 
    1006      *      - 'name' 
    1007      *      - 'taxonomy' 
    1008      *      Also, it can optionally contain: 
    1009      *      - 'parent' 
    1010      *      - 'description' 
    1011      *      - 'slug' 
    1012      * @return int term_id 
    1013      */ 
    1014     function wp_newTerm( $args ) { 
    1015         $this->escape( $args ); 
    1016  
    1017         $blog_id            = (int) $args[0]; 
    1018         $username           = $args[1]; 
    1019         $password           = $args[2]; 
    1020         $content_struct     = $args[3]; 
    1021  
    1022         if ( ! $user = $this->login( $username, $password ) ) 
    1023             return $this->error; 
    1024  
    1025         do_action( 'xmlrpc_call', 'wp.newTerm' ); 
    1026  
    1027         if ( ! taxonomy_exists( $content_struct['taxonomy'] ) ) 
    1028             return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
    1029  
    1030         $taxonomy = get_taxonomy( $content_struct['taxonomy'] ); 
    1031  
    1032         if( ! current_user_can( $taxonomy->cap->manage_terms ) ) 
    1033             return new IXR_Error( 401, __( 'You are not allowed to create terms in this taxonomy.' ) ); 
    1034  
    1035         $taxonomy = (array)$taxonomy; 
    1036  
    1037         // hold the data of the term 
    1038         $term_data = array(); 
    1039  
    1040         $term_data['name'] = trim( $content_struct['name'] ); 
    1041         if ( empty ( $term_data['name'] ) ) 
    1042             return new IXR_Error( 403, __( 'The term name cannot be empty.' ) ); 
    1043  
    1044         if( isset ( $content_struct['parent'] ) ) { 
    1045             if( ! $taxonomy['hierarchical'] ) 
    1046                 return new IXR_Error( 403, __( 'This taxonomy is not hierarchical.' ) ); 
    1047  
    1048             $parent_term_id = (int) $content_struct['parent']; 
    1049             $parent_term = get_term( $parent_term_id , $taxonomy['name'] ); 
    1050  
    1051             if ( is_wp_error( $parent_term ) ) 
    1052                 return new IXR_Error( 500, $parent_term->get_error_message() ); 
    1053  
    1054             if ( ! $parent_term ) 
    1055                 return new IXR_Error( 500, __('Parent term does not exist.') ); 
    1056  
    1057             $term_data['parent'] = $content_struct['parent']; 
    1058         } 
    1059  
    1060         $term_data['description'] = ''; 
    1061         if( isset ( $content_struct['description'] ) ) 
    1062             $term_data['description'] = $content_struct['description']; 
    1063  
    1064         $term_data['slug'] = ''; 
    1065         if( isset ( $content_struct['slug'] ) ) 
    1066             $term_data['slug'] = $content_struct['slug']; 
    1067  
    1068         $term = wp_insert_term( $term_data['name'] , $taxonomy['name'] , $term_data ); 
    1069  
    1070         if ( is_wp_error( $term ) ) 
    1071             return new IXR_Error( 500, $term->get_error_message() ); 
    1072  
    1073         if ( ! $term ) 
    1074             return new IXR_Error( 500, __('Sorry, your term could not be created. Something wrong happened.') ); 
    1075  
    1076         return $term['term_id']; 
    1077     } 
    1078  
    1079     /** 
    1080      * Edit a term 
    1081      * 
    1082      * @uses wp_update_term() 
    1083      * @param array $args Method parameters. Contains: 
    1084      *  - int     $blog_id 
    1085      *  - string  $username 
    1086      *  - string  $password 
    1087      *  - int     $term_id 
    1088      *  - array   $content_struct. 
    1089      *      The $content_struct must contain: 
    1090      *      - 'taxonomy' 
    1091      *      Also, it can optionally contain: 
    1092      *      - 'name' 
    1093      *      - 'parent' 
    1094      *      - 'description' 
    1095      *      - 'slug' 
    1096      *  - boolean $send_mail optional. Defaults to false 
    1097      * @return int term_id 
    1098      */ 
    1099     function wp_editTerm( $args ) { 
    1100         $this->escape( $args ); 
    1101  
    1102         $blog_id            = (int) $args[0]; 
    1103         $username           = $args[1]; 
    1104         $password           = $args[2]; 
    1105         $term_id            = (int) $args[3]; 
    1106         $content_struct     = $args[4]; 
    1107  
    1108         if ( ! $user = $this->login( $username, $password ) ) 
    1109             return $this->error; 
    1110  
    1111         do_action( 'xmlrpc_call', 'wp.editTerm' ); 
    1112  
    1113         if ( ! taxonomy_exists( $content_struct['taxonomy'] ) ) 
    1114             return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
    1115  
    1116         $taxonomy = get_taxonomy( $content_struct['taxonomy'] ); 
    1117  
    1118         if( ! current_user_can( $taxonomy->cap->edit_terms ) ) 
    1119             return new IXR_Error( 401, __( 'You are not allowed to edit terms in this taxonomy.' ) ); 
    1120  
    1121         $taxonomy = (array) $taxonomy; 
    1122  
    1123         // hold the data of the term 
    1124         $term_data = array(); 
    1125  
    1126         $term = get_term( $term_id , $content_struct['taxonomy'] ); 
    1127  
    1128         if ( is_wp_error( $term ) ) 
    1129             return new IXR_Error( 500, $term->get_error_message() ); 
    1130  
    1131         if ( ! $term ) 
    1132             return new IXR_Error( 404, __('Invalid term ID.') ); 
    1133  
    1134         if( isset ( $content_struct['name'] ) ) { 
    1135             $term_data['name'] = trim( $content_struct['name'] ); 
    1136  
    1137             if( empty ( $term_data['name'] ) ) 
    1138                 return new IXR_Error( 403, __( 'The term name cannot be empty.' ) ); 
    1139         } 
    1140  
    1141         if( isset ( $content_struct['parent'] ) ) { 
    1142             if( ! $taxonomy['hierarchical'] ) 
    1143                 return new IXR_Error( 403, __( 'This taxonomy is not hierarchical.' ) ); 
    1144  
    1145             $parent_term_id = (int) $content_struct['parent']; 
    1146             $parent_term = get_term( $parent_term_id , $taxonomy['name'] ); 
    1147  
    1148             if ( is_wp_error( $parent_term) ) 
    1149                 return new IXR_Error( 500, $term->get_error_message() ); 
    1150  
    1151             if ( ! $parent_term ) 
    1152                 return new IXR_Error( 403, __('Invalid parent term ID.') ); 
    1153  
    1154             $term_data['parent'] = $content_struct['parent']; 
    1155         } 
    1156  
    1157         if( isset ( $content_struct['description'] ) ) 
    1158             $term_data['description'] = $content_struct['description']; 
    1159  
    1160         if( isset ( $content_struct['slug'] ) ) 
    1161             $term_data['slug'] = $content_struct['slug']; 
    1162  
    1163         $term = wp_update_term( $term_id , $taxonomy['name'] , $term_data ); 
    1164  
    1165         if ( is_wp_error( $term ) ) 
    1166             return new IXR_Error( 500, $term->get_error_message() ); 
    1167  
    1168         if ( ! $term ) 
    1169             return new IXR_Error( 500, __('Sorry, editing the term failed.') ); 
    1170  
    1171         return $term['term_id']; 
    1172     } 
    1173  
    1174     /** 
    1175      * Delete a  term 
    1176      * 
    1177      * @uses wp_delete_term() 
    1178      * @param array $args Method parameters. Contains: 
    1179      *  - int     $blog_id 
    1180      *  - string  $username 
    1181      *  - string  $password 
    1182      *  - int     $term_id 
    1183      *  - string  $taxnomy_name 
    1184      * @return boolean true 
    1185      */ 
    1186     function wp_deleteTerm( $args ) { 
    1187         $this->escape( $args ); 
    1188  
    1189         $blog_id            = (int) $args[0]; 
    1190         $username           = $args[1]; 
    1191         $password           = $args[2]; 
    1192         $term_id            = (int) $args[3]; 
    1193         $taxonomy_name      = $args[4]; 
    1194  
    1195         if ( ! $user = $this->login( $username, $password ) ) 
    1196             return $this->error; 
    1197  
    1198         do_action( 'xmlrpc_call', 'wp.editTerm' ); 
    1199  
    1200         if ( ! taxonomy_exists( $taxonomy_name ) ) 
    1201             return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
    1202  
    1203         $taxonomy = get_taxonomy( $taxonomy_name ); 
    1204  
    1205         if( ! current_user_can( $taxonomy->cap->delete_terms ) ) 
    1206             return new IXR_Error( 401, __( 'You are not allowed to delete terms in this taxonomy.' ) ); 
    1207  
    1208         $term = get_term ( $term_id, $taxonomy_name ); 
    1209  
    1210         if ( is_wp_error( $term ) ) 
    1211             return new IXR_Error( 500, $term->get_error_message() ); 
    1212  
    1213         if ( ! $term ) 
    1214             return new IXR_Error( 404, __('Invalid term ID.') ); 
    1215  
    1216         $result = wp_delete_term( $term_id, $taxonomy_name ); 
    1217  
    1218         if ( is_wp_error( $result ) ) 
    1219             return new IXR_Error( 500, $term->get_error_message() ); 
    1220  
    1221         if ( ! $result ) 
    1222             return new IXR_Error( 500, __('Sorry, deleting the term failed.') ); 
    1223  
    1224         return $result; 
    1225     } 
    1226  
    1227     /** 
    1228      * Retrieve a term 
    1229      * 
    1230      * @uses get_term() 
    1231      * @param array $args Method parameters. Contains: 
    1232      *  - int     $blog_id 
    1233      *  - string  $username 
    1234      *  - string  $password 
    1235      *  - string  $taxonomy_name 
    1236      *  - int     $term_id 
    1237      * @return array contains: 
    1238      *  - 'term_id' 
    1239      *  - 'name' 
    1240      *  - 'slug' 
    1241      *  - 'term_group' 
    1242      *  - 'term_taxonomy_id' 
    1243      *  - 'taxonomy' 
    1244      *  - 'description' 
    1245      *  - 'parent' 
    1246      *  - 'count' 
    1247      */ 
    1248     function wp_getTerm( $args ) { 
    1249         $this->escape( $args ); 
    1250  
    1251         $blog_id            = (int) $args[0]; 
    1252         $username           = $args[1]; 
    1253         $password           = $args[2]; 
    1254         $taxonomy_name      = $args[3]; 
    1255         $term_id            = (int)$args[4]; 
    1256  
    1257         if ( ! $user = $this->login( $username, $password ) ) 
    1258             return $this->error; 
    1259  
    1260         do_action( 'xmlrpc_call', 'wp.getTerm' ); 
    1261  
    1262         if ( ! taxonomy_exists( $taxonomy_name ) ) 
    1263             return new IXR_Error( 403, __( 'Invalid taxonomy name.' ) ); 
    1264  
    1265         $taxonomy = get_taxonomy( $taxonomy_name ); 
    1266  
    1267         if( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
    1268             return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) ); 
    1269  
    1270         $term = get_term( $term_id , $taxonomy_name ); 
    1271  
    1272         if ( is_wp_error( $term ) ) 
    1273             return new IXR_Error( 500, $term->get_error_message() ); 
    1274  
    1275         if ( ! $term ) 
    1276             return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
    1277  
    1278         return $this->prepare_term( $term ); 
    1279     } 
    1280  
    1281     /** 
    1282      * Retrieve terms 
    1283      * 
    1284      * @uses get_terms() 
    1285      * @param array $args Method parameters. Contains: 
    1286      *  - int     $blog_id 
    1287      *  - string  $username 
    1288      *  - string  $password 
    1289      *  - string   $taxonomy_name 
    1290      * @return array terms 
    1291      */ 
    1292     function wp_getTerms( $args ) { 
    1293         $this->escape( $args ); 
    1294  
    1295         $blog_id        = (int) $args[0]; 
    1296         $username       = $args[1]; 
    1297         $password       = $args[2]; 
    1298         $taxonomy_name  = $args[3]; 
    1299  
    1300         if ( ! $user = $this->login( $username, $password ) ) 
    1301             return $this->error; 
    1302  
    1303         do_action( 'xmlrpc_call', 'wp.getTerms' ); 
    1304  
    1305         if ( ! taxonomy_exists( $taxonomy_name ) ) 
    1306             return new IXR_Error( 403, __( 'Invalid taxonomy name.' ) ); 
    1307  
    1308         $taxonomy = get_taxonomy( $taxonomy_name ); 
    1309  
    1310         if( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
    1311             return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) ); 
    1312  
    1313         $terms = get_terms( $taxonomy_name , array( 'get' => 'all' ) ); 
    1314  
    1315         if ( is_wp_error( $terms ) ) 
    1316             return new IXR_Error( 500, $terms->get_error_message() ); 
    1317  
    1318         $struct = array(); 
    1319  
    1320         foreach ( $terms as $term ) { 
    1321             $struct[] = $this->prepare_term( $term ); 
    1322         } 
    1323  
    1324         return $struct; 
    1325     } 
    1326  
    1327     /** 
    1328      * Retrieve a taxonomy 
    1329      * 
    1330      * @uses get_taxonomy() 
    1331      * @param array $args Method parameters. Contains: 
    1332      *  - int     $blog_id 
    1333      *  - string  $username 
    1334      *  - string  $password 
    1335      *  - string  $taxonomy_name 
    1336      * @return array contains: 
    1337      *  - 'labels' 
    1338      *  - 'cap' 
    1339      *  - 'hierarchical' 
    1340      *  - 'object_type' 
    1341      */ 
    1342     function wp_getTaxonomy( $args ) { 
    1343         $this->escape( $args ); 
    1344  
    1345         $blog_id        = (int) $args[0]; 
    1346         $username       = $args[1]; 
    1347         $password       = $args[2]; 
    1348         $taxonomy_name  = $args[3]; 
    1349  
    1350         if ( ! $user = $this->login( $username, $password ) ) 
    1351             return $this->error; 
    1352  
    1353         do_action( 'xmlrpc_call', 'wp.getTaxonomy' ); 
    1354  
    1355         if( ! taxonomy_exists( $taxonomy_name ) ) 
    1356             return new IXR_Error( 403, __( 'The taxonomy type specified is not valid' ) ); 
    1357  
    1358         $taxonomy = get_taxonomy( $taxonomy_name ); 
    1359  
    1360         if( ! current_user_can( $taxonomy->cap->edit_terms ) ) 
    1361             return new IXR_Error( 401, __( 'Sorry, You are not allowed to edit this post type' ) ); 
    1362  
    1363         return $this->prepare_taxonomy( $taxonomy ); 
    1364     } 
    1365  
    1366     /** 
    1367      * Retrieve taxonomies 
    1368      * 
    1369      * @uses get_taxonomies() 
    1370      * @param array $args Method parameters. Contains: 
    1371      *  - int     $blog_id 
    1372      *  - string  $username 
    1373      *  - string  $password 
    1374      * @return array taxonomies 
    1375      */ 
    1376     function wp_getTaxonomies($args) { 
    1377         $this->escape( $args ); 
    1378  
    1379         $blog_id            = (int) $args[0]; 
    1380         $username           = $args[1]; 
    1381         $password           = $args[2]; 
    1382  
    1383         if ( ! $user = $this->login( $username, $password ) ) 
    1384             return $this->error; 
    1385  
    1386         do_action( 'xmlrpc_call', 'wp.getTaxonomies' ); 
    1387  
    1388         $taxonomies = get_taxonomies( '', 'objects' ); 
    1389  
    1390         // holds all the taxonomy data 
    1391         $struct = array(); 
    1392  
    1393         foreach( $taxonomies as $taxonomy ) { 
    1394             // capability check for post_types 
    1395             if( ! current_user_can( $taxonomy->cap->edit_terms ) ) 
    1396                 continue; 
    1397  
    1398             $struct[ $taxonomy->name ] = $this->prepare_taxonomy( $taxonomy ); 
    1399         } 
    1400  
    1401         return $struct; 
    140221    } 
    140322} 
Note: See TracChangeset for help on using the changeset viewer.