WordPress.org

Make WordPress Core

Ticket #18438: taxes.combo.patch

File taxes.combo.patch, 12.6 KB (added by maxcutler, 3 years ago)

Combined patch with the 7 new methods for cycle 2.

  • wp-includes/class-wp-xmlrpc-server.php

     
    3636                $this->methods = array( 
    3737                        // WordPress API 
    3838                        'wp.getUsersBlogs'              => 'this:wp_getUsersBlogs', 
     39                        'wp.newTerm'                    => 'this:wp_newTerm', 
     40                        'wp.editTerm'                   => 'this:wp_editTerm', 
     41                        'wp.deleteTerm'                 => 'this:wp_deleteTerm', 
     42                        'wp.getTerm'                    => 'this:wp_getTerm', 
     43                        'wp.getTerms'                   => 'this:wp_getTerms', 
     44                        'wp.getTaxonomy'                => 'this:wp_getTaxonomy', 
     45                        'wp.getTaxonomies'              => 'this:wp_getTaxonomies', 
    3946                        'wp.getPage'                    => 'this:wp_getPage', 
    4047                        'wp.getPages'                   => 'this:wp_getPages', 
    4148                        'wp.newPage'                    => 'this:wp_newPage', 
     
    447454        } 
    448455 
    449456        /** 
     457         * Prepares taxonomy data for return in an XML-RPC object. 
     458         * 
     459         * @param array|object $taxonomy The unprepared taxonomy data 
     460         * @return array The prepared taxonomy data 
     461         */ 
     462        function prepare_taxonomy( $taxonomy ) { 
     463                $_taxonomy = (array) $taxonomy; 
     464 
     465                unset( $_taxonomy['update_count_callback'] ); 
     466 
     467                return apply_filters( 'xmlrpc_prepare_taxonomy', $_taxonomy, $taxonomy ); 
     468        } 
     469 
     470        /** 
     471         * Prepares term data for return in an XML-RPC object. 
     472         * 
     473         * @param array $term The unprepared term data 
     474         * @return array The prepared term data 
     475         */ 
     476        function prepare_term( $term ) { 
     477                $_term = (array) $term; 
     478 
     479                return apply_filters( 'xmlrpc_prepare_term', $_term, $term ); 
     480        } 
     481 
     482        /** 
     483         * Create a new term. 
     484         * 
     485         * @uses wp_insert_term() 
     486         * @param array $args Method parameters. Contains: 
     487         *  - int     $blog_id 
     488         *  - string  $username 
     489         *  - string  $password 
     490         *  - array   $content_struct 
     491         *      The $content_struct must contain: 
     492         *      - 'name' 
     493         *      - 'taxonomy' 
     494         *      Also, it can optionally contain: 
     495         *      - 'parent' 
     496         *      - 'description' 
     497         *      - 'slug' 
     498         * @return int term_id 
     499         */ 
     500        function wp_newTerm( $args ) { 
     501                $this->escape( $args ); 
     502 
     503                $blog_id            = (int) $args[0]; 
     504                $username           = $args[1]; 
     505                $password           = $args[2]; 
     506                $content_struct     = $args[3]; 
     507 
     508                if ( ! $user = $this->login( $username, $password ) ) 
     509                        return $this->error; 
     510 
     511                do_action( 'xmlrpc_call', 'wp.newTerm' ); 
     512 
     513                if ( ! taxonomy_exists( $content_struct['taxonomy'] ) ) 
     514                        return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     515 
     516                $taxonomy = get_taxonomy( $content_struct['taxonomy'] ); 
     517 
     518                if ( ! current_user_can( $taxonomy->cap->manage_terms ) ) 
     519                        return new IXR_Error( 401, __( 'You are not allowed to create terms in this taxonomy.' ) ); 
     520 
     521                $taxonomy = (array) $taxonomy; 
     522 
     523                // hold the data of the term 
     524                $term_data = array(); 
     525 
     526                $term_data['name'] = trim( $content_struct['name'] ); 
     527                if ( empty( $term_data['name'] ) ) 
     528                        return new IXR_Error( 403, __( 'The term name cannot be empty.' ) ); 
     529 
     530                if ( isset( $content_struct['parent'] ) ) { 
     531                        if ( ! $taxonomy['hierarchical'] ) 
     532                                return new IXR_Error( 403, __( 'This taxonomy is not hierarchical.' ) ); 
     533 
     534                        $parent_term_id = (int) $content_struct['parent']; 
     535                        $parent_term = get_term( $parent_term_id , $taxonomy['name'] ); 
     536 
     537                        if ( is_wp_error( $parent_term ) ) 
     538                                return new IXR_Error( 500, $parent_term->get_error_message() ); 
     539 
     540                        if ( ! $parent_term ) 
     541                                return new IXR_Error( 500, __( 'Parent term does not exist.' ) ); 
     542 
     543                        $term_data['parent'] = $content_struct['parent']; 
     544                } 
     545 
     546                if ( isset( $content_struct['description'] ) ) 
     547                        $term_data['description'] = $content_struct['description']; 
     548 
     549                if ( isset( $content_struct['slug'] ) ) 
     550                        $term_data['slug'] = $content_struct['slug']; 
     551 
     552                $term = wp_insert_term( $term_data['name'] , $taxonomy['name'] , $term_data ); 
     553 
     554                if ( is_wp_error( $term ) ) 
     555                        return new IXR_Error( 500, $term->get_error_message() ); 
     556 
     557                if ( ! $term ) 
     558                        return new IXR_Error( 500, __( 'Sorry, your term could not be created. Something wrong happened.' ) ); 
     559 
     560                return $term['term_id']; 
     561        } 
     562 
     563        /** 
     564         * Edit a term. 
     565         * 
     566         * @uses wp_update_term() 
     567         * @param array $args Method parameters. Contains: 
     568         *  - int     $blog_id 
     569         *  - string  $username 
     570         *  - string  $password 
     571         *  - int     $term_id 
     572         *  - array   $content_struct 
     573         *      The $content_struct must contain: 
     574         *      - 'taxonomy' 
     575         *      Also, it can optionally contain: 
     576         *      - 'name' 
     577         *      - 'parent' 
     578         *      - 'description' 
     579         *      - 'slug' 
     580         * @return bool True, on success. 
     581         */ 
     582        function wp_editTerm( $args ) { 
     583                $this->escape( $args ); 
     584 
     585                $blog_id            = (int) $args[0]; 
     586                $username           = $args[1]; 
     587                $password           = $args[2]; 
     588                $term_id            = (int) $args[3]; 
     589                $content_struct     = $args[4]; 
     590 
     591                if ( ! $user = $this->login( $username, $password ) ) 
     592                        return $this->error; 
     593 
     594                do_action( 'xmlrpc_call', 'wp.editTerm' ); 
     595 
     596                if ( ! taxonomy_exists( $content_struct['taxonomy'] ) ) 
     597                        return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     598 
     599                $taxonomy = get_taxonomy( $content_struct['taxonomy'] ); 
     600 
     601                if ( ! current_user_can( $taxonomy->cap->edit_terms ) ) 
     602                        return new IXR_Error( 401, __( 'You are not allowed to edit terms in this taxonomy.' ) ); 
     603 
     604                $taxonomy = (array) $taxonomy; 
     605 
     606                // hold the data of the term 
     607                $term_data = array(); 
     608 
     609                $term = get_term( $term_id , $content_struct['taxonomy'] ); 
     610 
     611                if ( is_wp_error( $term ) ) 
     612                        return new IXR_Error( 500, $term->get_error_message() ); 
     613 
     614                if ( ! $term ) 
     615                        return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
     616 
     617                if ( isset( $content_struct['name'] ) ) { 
     618                        $term_data['name'] = trim( $content_struct['name'] ); 
     619 
     620                        if ( empty( $term_data['name'] ) ) 
     621                                return new IXR_Error( 403, __( 'The term name cannot be empty.' ) ); 
     622                } 
     623 
     624                if ( isset( $content_struct['parent'] ) ) { 
     625                        if ( ! $taxonomy['hierarchical'] ) 
     626                                return new IXR_Error( 403, __( 'This taxonomy is not hierarchical.' ) ); 
     627 
     628                        $parent_term_id = (int) $content_struct['parent']; 
     629                        $parent_term = get_term( $parent_term_id , $taxonomy['name'] ); 
     630 
     631                        if ( is_wp_error( $parent_term ) ) 
     632                                return new IXR_Error( 500, $term->get_error_message() ); 
     633 
     634                        if ( ! $parent_term ) 
     635                                return new IXR_Error( 403, __( 'Invalid parent term ID.' ) ); 
     636 
     637                        $term_data['parent'] = $content_struct['parent']; 
     638                } 
     639 
     640                if ( isset( $content_struct['description'] ) ) 
     641                        $term_data['description'] = $content_struct['description']; 
     642 
     643                if ( isset( $content_struct['slug'] ) ) 
     644                        $term_data['slug'] = $content_struct['slug']; 
     645 
     646                $term = wp_update_term( $term_id , $taxonomy['name'] , $term_data ); 
     647 
     648                if ( is_wp_error( $term ) ) 
     649                        return new IXR_Error( 500, $term->get_error_message() ); 
     650 
     651                if ( ! $term ) 
     652                        return new IXR_Error( 500, __( 'Sorry, editing the term failed.' ) ); 
     653 
     654                return true; 
     655        } 
     656 
     657        /** 
     658         * Delete a term. 
     659         * 
     660         * @uses wp_delete_term() 
     661         * @param array $args Method parameters. Contains: 
     662         *  - int     $blog_id 
     663         *  - string  $username 
     664         *  - string  $password 
     665         *  - string  $taxnomy_name 
     666         *  - int     $term_id 
     667         * @return boolean true 
     668         */ 
     669        function wp_deleteTerm( $args ) { 
     670                $this->escape( $args ); 
     671 
     672                $blog_id            = (int) $args[0]; 
     673                $username           = $args[1]; 
     674                $password           = $args[2]; 
     675                $taxonomy_name      = $args[3]; 
     676                $term_id            = (int) $args[4]; 
     677 
     678                if ( ! $user = $this->login( $username, $password ) ) 
     679                        return $this->error; 
     680 
     681                do_action( 'xmlrpc_call', 'wp.editTerm' ); 
     682 
     683                if ( ! taxonomy_exists( $taxonomy_name ) ) 
     684                        return new IXR_Error( 403, __( 'Invalid taxonomy.' ) ); 
     685 
     686                $taxonomy = get_taxonomy( $taxonomy_name ); 
     687 
     688                if ( ! current_user_can( $taxonomy->cap->delete_terms ) ) 
     689                        return new IXR_Error( 401, __( 'You are not allowed to delete terms in this taxonomy.' ) ); 
     690 
     691                $term = get_term( $term_id, $taxonomy_name ); 
     692 
     693                if ( is_wp_error( $term ) ) 
     694                        return new IXR_Error( 500, $term->get_error_message() ); 
     695 
     696                if ( ! $term ) 
     697                        return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
     698 
     699                $result = wp_delete_term( $term_id, $taxonomy_name ); 
     700 
     701                if ( is_wp_error( $result ) ) 
     702                        return new IXR_Error( 500, $term->get_error_message() ); 
     703 
     704                if ( ! $result ) 
     705                        return new IXR_Error( 500, __( 'Sorry, deleting the term failed.' ) ); 
     706 
     707                return $result; 
     708        } 
     709 
     710        /** 
     711         * Retrieve a term. 
     712         * 
     713         * @uses get_term() 
     714         * @param array $args Method parameters. Contains: 
     715         *  - int     $blog_id 
     716         *  - string  $username 
     717         *  - string  $password 
     718         *  - string  $taxonomy_name 
     719         *  - int     $term_id 
     720         * @return array contains: 
     721         *  - 'term_id' 
     722         *  - 'name' 
     723         *  - 'slug' 
     724         *  - 'term_group' 
     725         *  - 'term_taxonomy_id' 
     726         *  - 'taxonomy' 
     727         *  - 'description' 
     728         *  - 'parent' 
     729         *  - 'count' 
     730         */ 
     731        function wp_getTerm( $args ) { 
     732                $this->escape( $args ); 
     733 
     734                $blog_id            = (int) $args[0]; 
     735                $username           = $args[1]; 
     736                $password           = $args[2]; 
     737                $taxonomy_name      = $args[3]; 
     738                $term_id            = (int) $args[4]; 
     739 
     740                if ( ! $user = $this->login( $username, $password ) ) 
     741                        return $this->error; 
     742 
     743                do_action( 'xmlrpc_call', 'wp.getTerm' ); 
     744 
     745                if ( ! taxonomy_exists( $taxonomy_name ) ) 
     746                        return new IXR_Error( 403, __( 'Invalid taxonomy name.' ) ); 
     747 
     748                $taxonomy = get_taxonomy( $taxonomy_name ); 
     749 
     750                if ( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
     751                        return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) ); 
     752 
     753                $term = get_term( $term_id , $taxonomy_name ); 
     754 
     755                if ( is_wp_error( $term ) ) 
     756                        return new IXR_Error( 500, $term->get_error_message() ); 
     757 
     758                if ( ! $term ) 
     759                        return new IXR_Error( 404, __( 'Invalid term ID.' ) ); 
     760 
     761                return $this->prepare_term( $term ); 
     762        } 
     763 
     764        /** 
     765         * Retrieve all terms for a taxonomy. 
     766         * 
     767         * @uses get_terms() 
     768         * @param array $args Method parameters. Contains: 
     769         *  - int     $blog_id 
     770         *  - string  $username 
     771         *  - string  $password 
     772         *  - string   $taxonomy_name 
     773         * @return array terms 
     774         */ 
     775        function wp_getTerms( $args ) { 
     776                $this->escape( $args ); 
     777 
     778                $blog_id        = (int) $args[0]; 
     779                $username       = $args[1]; 
     780                $password       = $args[2]; 
     781                $taxonomy_name  = $args[3]; 
     782 
     783                if ( ! $user = $this->login( $username, $password ) ) 
     784                        return $this->error; 
     785 
     786                do_action( 'xmlrpc_call', 'wp.getTerms' ); 
     787 
     788                if ( ! taxonomy_exists( $taxonomy_name ) ) 
     789                        return new IXR_Error( 403, __( 'Invalid taxonomy name.' ) ); 
     790 
     791                $taxonomy = get_taxonomy( $taxonomy_name ); 
     792 
     793                if ( ! current_user_can( $taxonomy->cap->assign_terms ) ) 
     794                        return new IXR_Error( 401, __( 'You are not allowed to assign terms in this taxonomy.' ) ); 
     795 
     796                $terms = get_terms( $taxonomy_name , array( 'get' => 'all' ) ); 
     797 
     798                if ( is_wp_error( $terms ) ) 
     799                        return new IXR_Error( 500, $terms->get_error_message() ); 
     800 
     801                $struct = array(); 
     802 
     803                foreach ( $terms as $term ) { 
     804                        $struct[] = $this->prepare_term( $term ); 
     805                } 
     806 
     807                return $struct; 
     808        } 
     809 
     810        /** 
     811         * Retrieve a taxonomy. 
     812         * 
     813         * @uses get_taxonomy() 
     814         * @param array $args Method parameters. Contains: 
     815         *  - int     $blog_id 
     816         *  - string  $username 
     817         *  - string  $password 
     818         *  - string  $taxonomy_name 
     819         * @return array (@see get_taxonomy()) 
     820         */ 
     821        function wp_getTaxonomy( $args ) { 
     822                $this->escape( $args ); 
     823 
     824                $blog_id        = (int) $args[0]; 
     825                $username       = $args[1]; 
     826                $password       = $args[2]; 
     827                $taxonomy_name  = $args[3]; 
     828 
     829                if ( ! $user = $this->login( $username, $password ) ) 
     830                        return $this->error; 
     831 
     832                do_action( 'xmlrpc_call', 'wp.getTaxonomy' ); 
     833 
     834                if ( ! taxonomy_exists( $taxonomy_name ) ) 
     835                        return new IXR_Error( 403, __( 'The taxonomy type specified is not valid' ) ); 
     836 
     837                $taxonomy = get_taxonomy( $taxonomy_name ); 
     838 
     839                if ( ! current_user_can( $taxonomy->cap->edit_terms ) ) 
     840                        return new IXR_Error( 401, __( 'Sorry, You are not allowed to edit this post type' ) ); 
     841 
     842                return $this->prepare_taxonomy( $taxonomy ); 
     843        } 
     844 
     845        /** 
     846         * Retrieve all taxonomies. 
     847         * 
     848         * @uses get_taxonomies() 
     849         * @param array $args Method parameters. Contains: 
     850         *  - int     $blog_id 
     851         *  - string  $username 
     852         *  - string  $password 
     853         * @return array taxonomies 
     854         */ 
     855        function wp_getTaxonomies( $args ) { 
     856                $this->escape( $args ); 
     857 
     858                $blog_id            = (int) $args[0]; 
     859                $username           = $args[1]; 
     860                $password           = $args[2]; 
     861 
     862                if ( ! $user = $this->login( $username, $password ) ) 
     863                        return $this->error; 
     864 
     865                do_action( 'xmlrpc_call', 'wp.getTaxonomies' ); 
     866 
     867                $taxonomies = get_taxonomies( '', 'objects' ); 
     868 
     869                // holds all the taxonomy data 
     870                $struct = array(); 
     871 
     872                foreach ( $taxonomies as $taxonomy ) { 
     873                        // capability check for post_types 
     874                        if ( ! current_user_can( $taxonomy->cap->edit_terms ) ) 
     875                                continue; 
     876 
     877                        $struct[] = $this->prepare_taxonomy( $taxonomy ); 
     878                } 
     879 
     880                return $struct; 
     881        } 
     882 
     883        /** 
    450884         * Retrieve page. 
    451885         * 
    452886         * @since 2.2.0