WordPress.org

Plugin Directory

Changeset 500648


Ignore:
Timestamp:
02/05/12 16:46:25 (2 years ago)
Author:
maxcutler
Message:

Version 0.7 release.

Location:
xml-rpc-modernization/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • xml-rpc-modernization/trunk/class-wp-xmlrpc-server-ext.php

    r493326 r500648  
    2525 
    2626        // custom post type management 
     27        $new_methods['wp.newPost']          = array( &$this, 'wp_newPost' ); 
     28        $new_methods['wp.editPost']         = array( &$this, 'wp_editPost' ); 
     29        $new_methods['wp.deletePost']       = array( &$this, 'wp_deletePost' ); 
    2730        $new_methods['wp.getPost']          = array( &$this, 'wp_getPost' ); 
    2831        $new_methods['wp.getPosts']         = array( &$this, 'wp_getPosts' ); 
     
    4952 
    5053    /** 
    51      * Prepares user data for return in an XML-RPC object 
     54     * Prepares user data for return in an XML-RPC object. 
    5255     * 
    5356     * @param WP_User $user The unprepared user object 
     
    8285 
    8386        if ( in_array( 'all', $fields ) ) { 
    84             $_user = array_merge( $_user, $user_fields); 
     87            $_user = array_merge( $_user, $user_fields ); 
    8588        } 
    8689        else { 
     
    97100 
    98101    /** 
    99      * Prepares post data for return in an XML-RPC object 
     102     * Prepares post data for return in an XML-RPC object. 
    100103     * 
    101104     * @param array $post The unprepared post data 
     
    116119            'post_status'       => $post['post_status'], 
    117120            'post_type'         => $post['post_type'], 
    118             'post_slug'         => $post['post_name'], 
     121            'post_name'         => $post['post_name'], 
    119122            'post_author'       => $post['post_author'], 
    120123            'post_password'     => $post['post_password'], 
     
    124127            'comment_status'    => $post['comment_status'], 
    125128            'ping_status'       => $post['ping_status'], 
    126             'sticky'            => ($post['post_type'] === 'post' && is_sticky( $post['ID'] ) ), 
     129            'sticky'            => ( $post['post_type'] === 'post' && is_sticky( $post['ID'] ) ), 
    127130        ); 
    128131 
     
    198201 
    199202    /** 
    200      * Prepares taxonomy data for return in an XML-RPC object 
     203     * Prepares taxonomy data for return in an XML-RPC object. 
    201204     * 
    202205     * @param array|object $taxonomy The unprepared taxonomy data 
     
    212215 
    213216    /** 
    214      * Prepares term data for return in an XML-RPC object 
     217     * Prepares term data for return in an XML-RPC object. 
    215218     * 
    216219     * @param array $term The unprepared term data 
     
    224227 
    225228    /** 
    226      * Prepares post type data for return in an XML-RPC object 
     229     * Prepares post type data for return in an XML-RPC object. 
    227230     * 
    228231     * @param array|object $post_type The unprepared post type data 
     
    238241 
    239242    /** 
    240      * Create a new user 
     243     * Create a new user. 
    241244     * 
    242245     * @uses wp_insert_user() 
     
    245248     *  - string  $username 
    246249     *  - string  $password 
    247      *  - array   $content_struct. 
     250     *  - array   $content_struct 
    248251     *      The $content_struct must contain: 
    249252     *      - 'username' 
     
    259262     */ 
    260263    function wp_newUser( $args ) { 
    261         $this->escape($args); 
     264        $this->escape( $args ); 
    262265 
    263266        $blog_id        = (int) $args[0]; 
     
    329332 
    330333    /** 
    331      * Edit a new user 
     334     * Edit a user. 
    332335     * 
    333336     * @uses wp_update_user() 
     
    337340     *  - string  $password 
    338341     *  - int     $user_id 
    339      *  - array   $content_struct. 
     342     *  - array   $content_struct 
    340343     *      It can optionally contain: 
    341344     *      - 'email' 
     
    372375 
    373376        if ( ! ( $user_id == $user->ID || current_user_can( 'edit_users' ) ) ) 
    374             return new IXR_Error(401, __( 'Sorry, you cannot edit this user.' ) ); 
     377            return new IXR_Error( 401, __( 'Sorry, you cannot edit this user.' ) ); 
    375378 
    376379        // holds data of the user 
     
    446449 
    447450    /** 
    448      * Delete a user 
     451     * Delete a user. 
    449452     * 
    450453     * @uses wp_delete_user() 
     
    473476 
    474477        if ( ! get_userdata( $user_id ) ) 
    475             return new IXR_Error( 404, __('Invalid user ID.' ) ); 
     478            return new IXR_Error( 404, __( 'Invalid user ID.' ) ); 
    476479 
    477480        if ( $user->ID == $user_id ) 
     
    483486 
    484487            if ( ! get_userdata( $reassign_id ) ) 
    485                 return new IXR_Error( 404, __('Invalid reassign user ID.' ) ); 
     488                return new IXR_Error( 404, __( 'Invalid reassign user ID.' ) ); 
    486489 
    487490            if ( $reassign_id === $user_id ) 
     
    547550 
    548551        if ( ! $user_data ) 
    549             return new IXR_Error(404, __('Invalid user ID')); 
     552            return new IXR_Error( 404, __( 'Invalid user ID' ) ); 
    550553 
    551554        if ( ! ( $user_id == $user->ID || current_user_can( 'edit_users' ) ) ) 
     
    595598        do_action( 'xmlrpc_call', 'wp.getUsers' ); 
    596599 
    597         if ( ! current_user_can( 'edit_users' )) 
     600        if ( ! current_user_can( 'edit_users' ) ) 
    598601            return new IXR_Error( 401, __( 'Sorry, you cannot edit users.' ) ); 
    599602 
     
    655658 
    656659        return $user; 
     660    } 
     661 
     662    /** 
     663     * Create a new post for any registered post type. 
     664     * 
     665     * @uses wp_insert_post() 
     666     * @param array $args Method parameters. Contains: 
     667     *  - int     $blog_id 
     668     *  - string  $username 
     669     *  - string  $password 
     670     *  - array   $content_struct 
     671     *      $content_struct can contain: 
     672     *      - post_type (default: 'post') 
     673     *      - post_status (default: 'draft') 
     674     *      - post_title 
     675     *      - post_author 
     676     *      - post_exerpt 
     677     *      - post_content 
     678     *      - post_date_gmt | post_date 
     679     *      - post_format 
     680     *      - post_password 
     681     *      - comment_status - can be 'open' | 'closed' 
     682     *      - ping_status - can be 'open' | 'closed' 
     683     *      - sticky 
     684     *      - custom_fields - array, with each element containing 'key' and 'value' 
     685     *      - terms - array, with taxonomy names as keys and arrays of term IDs as values 
     686     *      - terms_names - array, with taxonomy names as keys and arrays of term names as values 
     687     *      - enclosure 
     688     *      - any other fields supported by wp_insert_post() 
     689     * @return string post_id 
     690     */ 
     691    function wp_newPost( $args ) { 
     692        $this->escape( $args ); 
     693 
     694        $blog_id        = (int) $args[0]; 
     695        $username       = $args[1]; 
     696        $password       = $args[2]; 
     697        $content_struct = $args[3]; 
     698 
     699        if ( ! $user = $this->login( $username, $password ) ) 
     700            return $this->error; 
     701 
     702        do_action( 'xmlrpc_call', 'wp.newPost' ); 
     703 
     704        unset( $content_struct['ID'] ); 
     705 
     706        return $this->_wp_insertPost( $user, $content_struct ); 
     707    } 
     708 
     709    /* 
     710     * Helper method for wp_newPost and wp_editPost, containing shared logic. 
     711     */ 
     712    function _wp_insertPost( $user, $content_struct ) { 
     713        $defaults = array( 'post_status' => 'draft', 'post_type' => 'post', 'post_author' => 0, 
     714            'post_password' => '', 'post_excerpt' => '', 'post_content' => '', 'post_title' => '', 'sticky' => 0 ); 
     715 
     716        $post_data = wp_parse_args( $content_struct, $defaults ); 
     717 
     718        $post_type = get_post_type_object( $post_data['post_type'] ); 
     719        if( ! ( (bool) $post_type ) ) 
     720            return new IXR_Error( 403, __( 'Invalid post type' ) ); 
     721 
     722        if( ! current_user_can( $post_type->cap->edit_posts ) ) 
     723            return new IXR_Error( 401, __( 'Sorry, you are not allowed to post on this site.' ) ); 
     724 
     725        switch ( $post_data['post_status'] ) { 
     726            case 'draft': 
     727            case 'pending': 
     728                break; 
     729            case 'private': 
     730                if( ! current_user_can( $post_type->cap->publish_posts ) ) 
     731                    return new IXR_Error( 401, __( 'Sorry, you are not allowed to create private posts in this post type' )); 
     732                break; 
     733            case 'publish': 
     734            case 'future': 
     735                if( ! current_user_can( $post_type->cap->publish_posts ) ) 
     736                    return new IXR_Error( 401, __( 'Sorry, you are not allowed to publish posts in this post type' )); 
     737                break; 
     738            default: 
     739                $post_data['post_status'] = 'draft'; 
     740            break; 
     741        } 
     742 
     743        if ( ! empty( $post_data['post_password'] ) && ! current_user_can( $post_type->cap->publish_posts ) ) 
     744            return new IXR_Error( 401, __( 'Sorry, you are not allowed to create password protected posts in this post type' ) ); 
     745 
     746 
     747        $post_data['post_author'] = absint( $post_data['post_author'] ); 
     748        if( ! empty( $post_data['post_author'] ) && $post_data['post_author'] != $user->ID ) { 
     749            if( ! current_user_can( $post_type->cap->edit_others_posts ) ) 
     750                return new IXR_Error( 401, __( 'You are not allowed to create posts as this user.' ) ); 
     751 
     752            $author = get_userdata( $post_data['post_author'] ); 
     753 
     754            if( ! $author ) 
     755                return new IXR_Error( 404, __( 'Invalid author ID.' ) ); 
     756        } 
     757        else { 
     758            $post_data['post_author'] = $user->ID; 
     759        } 
     760 
     761        if( isset( $post_data['comment_status'] ) ) 
     762            if( ! post_type_supports( $post_data['post_type'], 'comments' ) || ( $post_data['comment_status'] != 'open' && $post_data['comment_status'] != 'closed' ) ) 
     763                unset( $post_data['comment_status'] ); 
     764 
     765        if( isset( $post_data['ping_status'] ) ) 
     766            if( ! post_type_supports( $post_data['post_type'], 'trackbacks' ) || ( $post_data['ping_status'] != 'open' && $post_data['ping_status'] != 'closed' ) ) 
     767                unset( $post_data['ping_status'] ); 
     768 
     769        // Do some timestamp voodoo 
     770        if ( ! empty( $post_data['post_date_gmt'] ) ) 
     771            $dateCreated = str_replace( 'Z', '', $post_data['post_date_gmt']->getIso() ) . 'Z'; // We know this is supposed to be GMT, so we're going to slap that Z on there by force 
     772        elseif ( ! empty( $post_data['post_date'] ) ) 
     773            $dateCreated = $post_data['post_date']->getIso(); 
     774 
     775        if ( ! empty( $dateCreated ) ) { 
     776            $post_data['post_date'] = get_date_from_gmt( iso8601_to_datetime( $dateCreated ) ); 
     777            $post_data['post_date_gmt'] = iso8601_to_datetime( $dateCreated, 'GMT' ); 
     778        } 
     779 
     780        if ( ! isset( $post_data['ID'] ) ) { 
     781            $post_data['ID'] = get_default_post_to_edit( $post_data['post_type'], true )->ID; 
     782        } 
     783        $post_ID = $post_data['ID']; 
     784 
     785        $sticky = $post_data['sticky'] ? true : false; 
     786 
     787        if( $post_data['post_type'] == 'post' && $sticky == true ) { 
     788            if( ! current_user_can( $post_type->cap->edit_others_posts ) ) 
     789                return new IXR_Error( 401, __( 'Sorry, you are not allowed to stick this post.' ) ); 
     790 
     791            if( $post_data['post_status'] != 'publish' ) 
     792                return new IXR_Error( 401, __( 'Only published posts can be made sticky.' ) ); 
     793 
     794            stick_post( $post_ID ); 
     795        } 
     796 
     797        if( isset ( $post_data['custom_fields'] ) && post_type_supports( $post_data['post_type'], 'custom-fields' ) ) { 
     798            $this->set_custom_fields( $post_ID, $post_data['custom_fields'] ); 
     799        } 
     800 
     801        if( isset( $post_data['terms'] ) || isset( $post_data['terms_names'] ) ) { 
     802            $post_type_taxonomies = get_object_taxonomies( $post_data['post_type'], 'objects' ); 
     803 
     804            // accumulate term IDs from terms and terms_names 
     805            $terms = array(); 
     806 
     807            // first validate the terms specified by ID 
     808            if( isset( $post_data['terms'] ) && is_array( $post_data['terms'] ) ) { 
     809                $taxonomies = array_keys( $post_data['terms'] ); 
     810 
     811                // validating term ids 
     812                foreach ( $taxonomies as $taxonomy ) { 
     813                    if ( ! array_key_exists( $taxonomy , $post_type_taxonomies ) ) 
     814                        return new IXR_Error( 401, __( 'Sorry, one of the given taxonomy is not supported by the post type.' ) ); 
     815 
     816                    if( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->assign_terms ) ) 
     817                        return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies' ) ); 
     818 
     819                    $term_ids = $post_data['terms'][$taxonomy]; 
     820                    foreach ( $term_ids as $term_id ) { 
     821                        $term = get_term_by( 'id', $term_id, $taxonomy ); 
     822 
     823                        if ( ! $term ) 
     824                            return new IXR_Error( 403, __( 'Invalid term ID' ) ); 
     825 
     826                        $terms[$taxonomy][] = (int) $term_id; 
     827                    } 
     828                } 
     829            } 
     830 
     831            // now validate terms specified by name 
     832            if ( isset( $post_data['terms_names'] ) && is_array( $post_data['terms_names'] ) ) { 
     833                $taxonomies = array_keys( $post_data['terms_names'] ); 
     834 
     835                foreach ( $taxonomies as $taxonomy ) { 
     836                    if ( ! array_key_exists( $taxonomy , $post_type_taxonomies ) ) 
     837                        return new IXR_Error( 401, __( 'Sorry, one of the given taxonomy is not supported by the post type.' ) ); 
     838 
     839                    if( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->assign_terms ) ) 
     840                        return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies.' ) ); 
     841 
     842                    // for hierarchical taxonomies, we can't assign a term when multiple terms in the hierarchy share the same name 
     843                    $ambiguous_terms = array(); 
     844                    if( is_taxonomy_hierarchical( $taxonomy ) ) { 
     845                        $tax_term_names = get_terms( $taxonomy, array( 'fields' => 'names', 'hide_empty' => false ) ); 
     846 
     847                        // count the number of terms with the same name 
     848                        $tax_term_names_count = array_count_values( $tax_term_names ); 
     849 
     850                        // filter out non-ambiguous term names 
     851                        $ambiguous_tax_term_counts = array_filter( $tax_term_names_count, function( $count ){ 
     852                            return $count > 1; 
     853                        } ); 
     854 
     855                        $ambiguous_terms = array_keys( $ambiguous_tax_term_counts ); 
     856                    } 
     857 
     858                    $term_names = $post_data['terms_names'][$taxonomy]; 
     859                    foreach ( $term_names as $term_name ) { 
     860                        if ( in_array( $term_name, $ambiguous_terms ) ) 
     861                            return new IXR_Error( 401, __( 'Ambiguous term name used in a hierarhical taxonomy. Please use term ID instead.' ) ); 
     862 
     863                        $term = get_term_by( 'name', $term_name, $taxonomy ); 
     864 
     865                        if ( ! $term ) { 
     866                            // term doesn't exist, so check that the user is allowed to create new terms 
     867                            if( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->edit_terms ) ) 
     868                                return new IXR_Error( 401, __( 'Sorry, you are not allowed to add a term to one of the given taxonomies.' ) ); 
     869 
     870                            // create the new term 
     871                            $term_info = wp_insert_term( $term_name, $taxonomy ); 
     872                            if ( is_wp_error( $term_info ) ) 
     873                                return new IXR_Error( 500, $term_info->get_error_message() ); 
     874 
     875                            $terms[$taxonomy][] = (int) $term_info['term_id']; 
     876                        } 
     877                        else { 
     878                            $terms[$taxonomy][] = (int) $term->term_id; 
     879                        } 
     880                    } 
     881                } 
     882            } 
     883 
     884            $post_data['tax_input'] = $terms; 
     885            unset( $post_data['terms'] ); 
     886            unset( $post_data['terms_names'] ); 
     887        } 
     888        else { 
     889            // do not allow direct submission of 'tax_input', clients must use 'terms' and/or 'terms_names' 
     890            unset( $post_data['tax_input'] ); 
     891        } 
     892 
     893        if( isset( $post_data['post_format'] ) ) { 
     894            $format = set_post_format( $post_ID, $post_data['post_format'] ); 
     895 
     896            if ( is_wp_error( $format ) ) 
     897                return new IXR_Error( 500, $format->get_error_message() ); 
     898 
     899            unset( $post_data['post_format'] ); 
     900        } 
     901 
     902        // Handle enclosures 
     903        $enclosure = isset( $post_data['enclosure'] ) ? $post_data['enclosure'] : null; 
     904        $this->add_enclosure_if_new( $post_ID, $enclosure ); 
     905 
     906        $this->attach_uploads( $post_ID, $post_data['post_content'] ); 
     907 
     908        $post_data = apply_filters( 'xmlrpc_wp_insert_post_data', $post_data, $content_struct ); 
     909 
     910        $post_ID = wp_insert_post( $post_data, true ); 
     911        if ( is_wp_error( $post_ID ) ) 
     912            return new IXR_Error( 500, $post_ID->get_error_message() ); 
     913 
     914        if ( ! $post_ID ) 
     915            return new IXR_Error( 401, __( 'Sorry, your entry could not be posted. Something wrong happened.' ) ); 
     916 
     917        return strval( $post_ID ); 
     918    } 
     919 
     920    /* 
     921     * Edit a post for any registered post type. 
     922     * 
     923     * The $content_struct parameter only needs to contain fields that 
     924     * should be changed. All other fields will retain their existing values. 
     925     * 
     926     * @uses wp_insert_post() 
     927     * @param array $args Method parameters. Contains: 
     928     *  - int     $blog_id 
     929     *  - string  $username 
     930     *  - string  $password 
     931     *  - int     $post_id 
     932     *  - array   $content_struct 
     933     * @return true on success 
     934     */ 
     935    function wp_editPost( $args ) { 
     936        $this->escape( $args ); 
     937 
     938        $blog_id        = (int) $args[0]; // we will support this in the near future 
     939        $username       = $args[1]; 
     940        $password       = $args[2]; 
     941        $post_id        = (int) $args[3]; 
     942        $content_struct = $args[4]; 
     943 
     944        if ( ! $user = $this->login( $username, $password ) ) 
     945            return $this->error; 
     946 
     947        do_action( 'xmlrpc_call', 'wp.editPost' ); 
     948 
     949        $post = get_post( $post_id, ARRAY_A ); 
     950 
     951        if ( empty( $post["ID"] ) ) 
     952            return new IXR_Error( 404, __( 'Invalid post ID.' ) ); 
     953 
     954        // convert the date field back to IXR form 
     955        $post['post_date'] = new IXR_Date( mysql2date( 'Ymd\TH:i:s', $post['post_date'], false ) ); 
     956 
     957        // ignore the existing GMT date if it is empty or a non-GMT date was supplied in $content_struct, 
     958        // since _wp_insertPost will ignore the non-GMT date if the GMT date is set 
     959        if ( $post['post_date_gmt'] == '0000-00-00 00:00:00' || isset( $content_struct['post_date'] ) ) 
     960            unset( $post['post_date_gmt'] ); 
     961        else 
     962            $post['post_date_gmt'] = new IXR_Date( mysql2date( 'Ymd\TH:i:s', $post['post_date_gmt'], false ) ); 
     963 
     964        $this->escape( $post ); 
     965        $merged_content_struct = array_merge( $post, $content_struct ); 
     966 
     967        $retval = $this->_wp_insertPost( $user, $merged_content_struct ); 
     968        if ( $retval instanceof IXR_Error ) 
     969            return $retval; 
     970 
     971        return true; 
     972    } 
     973 
     974    /** 
     975     * Delete a post for any registered post type. 
     976     * 
     977     * @uses wp_delete_post() 
     978     * @param array $args Method parameters. Contains: 
     979     *  - int     $blog_id 
     980     *  - string  $username 
     981     *  - string  $password 
     982     *  - int     $post_id 
     983     * @return true on success 
     984     */ 
     985    function wp_deletePost( $args ) { 
     986        $this->escape( $args ); 
     987 
     988        $blog_id    = (int) $args[0]; 
     989        $username   = $args[1]; 
     990        $password   = $args[2]; 
     991        $post_id    = (int) $args[3]; 
     992 
     993        if ( ! $user = $this->login( $username, $password ) ) 
     994            return $this->error; 
     995 
     996        do_action( 'xmlrpc_call', 'wp.deletePost' ); 
     997 
     998        $post = wp_get_single_post( $post_id, ARRAY_A ); 
     999        if ( empty( $post['ID'] ) ) 
     1000            return new IXR_Error( 404, __( 'Invalid post ID.' ) ); 
     1001 
     1002        $post_type = get_post_type_object( $post['post_type'] ); 
     1003        if( ! current_user_can( $post_type->cap->delete_post, $post_id ) ) 
     1004            return new IXR_Error( 401, __( 'Sorry, you are not allowed to delete this post.' ) ); 
     1005 
     1006        $result = wp_delete_post( $post_id ); 
     1007 
     1008        if ( ! $result ) 
     1009            return new IXR_Error( 500, __( 'The post cannot be deleted.' ) ); 
     1010 
     1011        return true; 
    6571012    } 
    6581013 
     
    6841039     *  - 'post_status' 
    6851040     *  - 'post_type' 
    686      *  - 'post_slug' 
     1041     *  - 'post_name' 
    6871042     *  - 'post_author' 
    6881043     *  - 'post_password' 
     
    7241079        $post_type = get_post_type_object( $post['post_type'] ); 
    7251080        if ( ! current_user_can( $post_type->cap->edit_posts, $post_id ) ) 
    726             return new IXR_Error( 401, __( 'Sorry, you cannot edit this post.' )); 
     1081            return new IXR_Error( 401, __( 'Sorry, you cannot edit this post.' ) ); 
    7271082 
    7281083        return $this->prepare_post( $post, $fields ); 
     
    7731128        if ( isset( $filter['post_type'] ) ) { 
    7741129            $post_type = get_post_type_object( $filter['post_type'] ); 
    775             if ( ! ( (bool)$post_type ) ) 
     1130            if ( ! ( (bool) $post_type ) ) 
    7761131                return new IXR_Error( 403, __( 'The post type specified is not valid' ) ); 
    7771132 
     
    7981153        } 
    7991154 
    800         do_action('xmlrpc_call', 'wp.getPosts'); 
     1155        do_action( 'xmlrpc_call', 'wp.getPosts' ); 
    8011156 
    8021157        $posts_list = wp_get_recent_posts( $query ); 
     
    8201175 
    8211176    /** 
    822      * Retrieve post terms 
     1177     * Retrieve post terms. 
    8231178     * 
    8241179     * The optional $group_by_taxonomy parameter specifies whether 
     
    8711226                $taxonomy = $term->taxonomy; 
    8721227 
    873                 if ( ! in_array( $taxonomy, $struct ) ) 
     1228                if ( ! array_key_exists( $taxonomy, $struct ) ) 
    8741229                    $struct[$taxonomy] = array(); 
    8751230 
     
    8851240 
    8861241    /** 
    887      * Set post terms 
     1242     * Set post terms. 
    8881243     * 
    8891244     * @uses wp_set_object_terms() 
     
    8981253     */ 
    8991254    function wp_setPostTerms( $args ) { 
    900         $this->escape($args); 
     1255        $this->escape( $args ); 
    9011256 
    9021257        $blog_id            = (int) $args[0]; 
     
    9541309 
    9551310    /** 
    956      * Retrieves a post type 
     1311     * Retrieve a post type. 
    9571312     * 
    9581313     * @uses get_post_type_object() 
     
    9971352 
    9981353    /** 
    999      * Retrieves a post types 
     1354     * Retrieve all post types. 
    10001355     * 
    10011356     * @uses get_post_types() 
     
    10331388 
    10341389    /** 
    1035      * Create a new term 
     1390     * Create a new term. 
    10361391     * 
    10371392     * @uses wp_insert_term() 
     
    10401395     *  - string  $username 
    10411396     *  - string  $password 
    1042      *  - array   $content_struct. 
     1397     *  - array   $content_struct 
    10431398     *      The $content_struct must contain: 
    10441399     *      - 'name' 
     
    10911446 
    10921447            if ( ! $parent_term ) 
    1093                 return new IXR_Error( 500, __('Parent term does not exist.') ); 
     1448                return new IXR_Error( 500, __( 'Parent term does not exist.' ) ); 
    10941449 
    10951450            $term_data['parent'] = $content_struct['parent']; 
     
    11081463 
    11091464        if ( ! $term ) 
    1110             return new IXR_Error( 500, __('Sorry, your term could not be created. Something wrong happened.') ); 
     1465            return new IXR_Error( 500, __( 'Sorry, your term could not be created. Something wrong happened.' ) ); 
    11111466 
    11121467        return $term['term_id']; 
     
    11141469 
    11151470    /** 
    1116      * Edit a term 
     1471     * Edit a term. 
    11171472     * 
    11181473     * @uses wp_update_term() 
     
    11221477     *  - string  $password 
    11231478     *  - int     $term_id 
    1124      *  - array   $content_struct. 
     1479     *  - array   $content_struct 
    11251480     *      The $content_struct must contain: 
    11261481     *      - 'taxonomy' 
     
    11811536            $parent_term = get_term( $parent_term_id , $taxonomy['name'] ); 
    11821537 
    1183             if ( is_wp_error( $parent_term) ) 
     1538            if ( is_wp_error( $parent_term ) ) 
    11841539                return new IXR_Error( 500, $term->get_error_message() ); 
    11851540 
     
    12021557 
    12031558        if ( ! $term ) 
    1204             return new IXR_Error( 500, __('Sorry, editing the term failed.') ); 
     1559            return new IXR_Error( 500, __( 'Sorry, editing the term failed.' ) ); 
    12051560 
    12061561        return true; 
     
    12081563 
    12091564    /** 
    1210      * Delete a  term 
     1565     * Delete a term. 
    12111566     * 
    12121567     * @uses wp_delete_term() 
     
    12471602 
    12481603        if ( ! $term ) 
    1249             return new IXR_Error( 404, __('Invalid term ID.') ); 
     1604            return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
    12501605 
    12511606        $result = wp_delete_term( $term_id, $taxonomy_name ); 
     
    12551610 
    12561611        if ( ! $result ) 
    1257             return new IXR_Error( 500, __('Sorry, deleting the term failed.') ); 
     1612            return new IXR_Error( 500, __( 'Sorry, deleting the term failed.' ) ); 
    12581613 
    12591614        return $result; 
     
    12611616 
    12621617    /** 
    1263      * Retrieve a term 
     1618     * Retrieve a term. 
    12641619     * 
    12651620     * @uses get_term() 
     
    12881643        $password           = $args[2]; 
    12891644        $taxonomy_name      = $args[3]; 
    1290         $term_id            = (int)$args[4]; 
     1645        $term_id            = (int) $args[4]; 
    12911646 
    12921647        if ( ! $user = $this->login( $username, $password ) ) 
     
    13151670 
    13161671    /** 
    1317      * Retrieve terms 
     1672     * Retrieve all terms for a taxonomy. 
    13181673     * 
    13191674     * @uses get_terms() 
     
    13611716 
    13621717    /** 
    1363      * Retrieve a taxonomy 
     1718     * Retrieve a taxonomy. 
    13641719     * 
    13651720     * @uses get_taxonomy() 
     
    13961751 
    13971752    /** 
    1398      * Retrieve taxonomies 
     1753     * Retrieve all taxonomies. 
    13991754     * 
    14001755     * @uses get_taxonomies() 
     
    14051760     * @return array taxonomies 
    14061761     */ 
    1407     function wp_getTaxonomies($args) { 
     1762    function wp_getTaxonomies( $args ) { 
    14081763        $this->escape( $args ); 
    14091764 
  • xml-rpc-modernization/trunk/readme.txt

    r493326 r500648  
    1717although the exposed API methods are not compatible (different parameter names/types/orders). 
    1818 
    19 WARNING: This plugin should not be used in production, and is intended as a testing ground 
    20 for new methods before incorporation into WordPress core. 
     19WARNING: This plugin is still experimental, use in production at your own risk. 
    2120 
    2221= Methods = 
     
    2726* wp.getUser - get information about a specific user 
    2827* wp.getUsers - retrieve a list of users 
    29 * wp.getPost  - get a specific post (from any post type) 
     28* wp.getUserInfo - get information about the requesting user 
     29* wp.newPost - create a new post (of any post type) 
     30* wp.editPost - edit a post (of any post type) 
     31* wp.deletePost - delete a post (of any post type) 
     32* wp.getPost  - get a specific post (of any post type) 
    3033* wp.getPosts  - get a list of posts 
    3134* wp.getPostType - get information about a specific post type 
     
    4346== Changelog == 
    4447 
     48= 0.7 = 
     49* Added wp.newPost, wp.editPost, and wp.deletePost methods. 
     50 
    4551= 0.6 = 
    4652* Revised implementations of many methods. 
  • xml-rpc-modernization/trunk/wp-xmlrpc-modernization.php

    r493326 r500648  
    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.6 
     6 * Version: 0.7 
    77 * Author: Max Cutler 
    88 * Author URI: http://www.maxcutler.com 
Note: See TracChangeset for help on using the changeset viewer.