WP_REST_Post_Types_Controller

Core class to access post types via the REST API.

Defined (1)

The class is defined in the following location(s).

/wp-includes/rest-api/endpoints/class-wp-rest-post-types-controller.php  
  1. class WP_REST_Post_Types_Controller extends WP_REST_Controller { 
  2.  
  3.     /** 
  4.      * Constructor. 
  5.      * 
  6.      * @since 4.7.0 
  7.      * @access public 
  8.      */ 
  9.     public function __construct() { 
  10.         $this->namespace = 'wp/v2'; 
  11.         $this->rest_base = 'types'; 
  12.     } 
  13.  
  14.     /** 
  15.      * Registers the routes for the objects of the controller. 
  16.      * 
  17.      * @since 4.7.0 
  18.      * @access public 
  19.      * 
  20.      * @see register_rest_route() 
  21.      */ 
  22.     public function register_routes() { 
  23.  
  24.         register_rest_route( $this->namespace, '/' . $this->rest_base, array( 
  25.             array( 
  26.                 'methods' => WP_REST_Server::READABLE,  
  27.                 'callback' => array( $this, 'get_items' ),  
  28.                 'permission_callback' => array( $this, 'get_items_permissions_check' ),  
  29.                 'args' => $this->get_collection_params(),  
  30.  ),  
  31.             'schema' => array( $this, 'get_public_item_schema' ),  
  32.  ) ); 
  33.  
  34.         register_rest_route( $this->namespace, '/' . $this->rest_base . '/(?P<type>[\w-]+)', array( 
  35.             'args' => array( 
  36.                 'type' => array( 
  37.                     'description' => __( 'An alphanumeric identifier for the post type.' ),  
  38.                     'type' => 'string',  
  39.  ),  
  40.  ),  
  41.             array( 
  42.                 'methods' => WP_REST_Server::READABLE,  
  43.                 'callback' => array( $this, 'get_item' ),  
  44.                 'args' => array( 
  45.                     'context' => $this->get_context_param( array( 'default' => 'view' ) ),  
  46.  ),  
  47.  ),  
  48.             'schema' => array( $this, 'get_public_item_schema' ),  
  49.  ) ); 
  50.     } 
  51.  
  52.     /** 
  53.      * Checks whether a given request has permission to read types. 
  54.      * 
  55.      * @since 4.7.0 
  56.      * @access public 
  57.      * 
  58.      * @param WP_REST_Request $request Full details about the request. 
  59.      * @return WP_Error|true True if the request has read access, WP_Error object otherwise. 
  60.      */ 
  61.     public function get_items_permissions_check( $request ) { 
  62.         if ( 'edit' === $request['context'] ) { 
  63.             foreach ( get_post_types( array(), 'object' ) as $post_type ) { 
  64.                 if ( ! empty( $post_type->show_in_rest ) && current_user_can( $post_type->cap->edit_posts ) ) { 
  65.                     return true; 
  66.                 } 
  67.             } 
  68.  
  69.             return new WP_Error( 'rest_cannot_view', __( 'Sorry, you are not allowed to edit posts in this post type.' ), array( 'status' => rest_authorization_required_code() ) ); 
  70.         } 
  71.  
  72.         return true; 
  73.     } 
  74.  
  75.     /** 
  76.      * Retrieves all public post types. 
  77.      * 
  78.      * @since 4.7.0 
  79.      * @access public 
  80.      * 
  81.      * @param WP_REST_Request $request Full details about the request. 
  82.      * @return WP_Error|WP_REST_Response Response object on success, or WP_Error object on failure. 
  83.      */ 
  84.     public function get_items( $request ) { 
  85.         $data = array(); 
  86.  
  87.         foreach ( get_post_types( array(), 'object' ) as $obj ) { 
  88.             if ( empty( $obj->show_in_rest ) || ( 'edit' === $request['context'] && ! current_user_can( $obj->cap->edit_posts ) ) ) { 
  89.                 continue; 
  90.             } 
  91.  
  92.             $post_type = $this->prepare_item_for_response( $obj, $request ); 
  93.             $data[ $obj->name ] = $this->prepare_response_for_collection( $post_type ); 
  94.         } 
  95.  
  96.         return rest_ensure_response( $data ); 
  97.     } 
  98.  
  99.     /** 
  100.      * Retrieves a specific post type. 
  101.      * 
  102.      * @since 4.7.0 
  103.      * @access public 
  104.      * 
  105.      * @param WP_REST_Request $request Full details about the request. 
  106.      * @return WP_Error|WP_REST_Response Response object on success, or WP_Error object on failure. 
  107.      */ 
  108.     public function get_item( $request ) { 
  109.         $obj = get_post_type_object( $request['type'] ); 
  110.  
  111.         if ( empty( $obj ) ) { 
  112.             return new WP_Error( 'rest_type_invalid', __( 'Invalid post type.' ), array( 'status' => 404 ) ); 
  113.         } 
  114.  
  115.         if ( empty( $obj->show_in_rest ) ) { 
  116.             return new WP_Error( 'rest_cannot_read_type', __( 'Cannot view post type.' ), array( 'status' => rest_authorization_required_code() ) ); 
  117.         } 
  118.  
  119.         if ( 'edit' === $request['context'] && ! current_user_can( $obj->cap->edit_posts ) ) { 
  120.             return new WP_Error( 'rest_forbidden_context', __( 'Sorry, you are not allowed to edit posts in this post type.' ), array( 'status' => rest_authorization_required_code() ) ); 
  121.         } 
  122.  
  123.         $data = $this->prepare_item_for_response( $obj, $request ); 
  124.  
  125.         return rest_ensure_response( $data ); 
  126.     } 
  127.  
  128.     /** 
  129.      * Prepares a post type object for serialization. 
  130.      * 
  131.      * @since 4.7.0 
  132.      * @access public 
  133.      * 
  134.      * @param stdClass        $post_type Post type data. 
  135.      * @param WP_REST_Request $request   Full details about the request. 
  136.      * @return WP_REST_Response Response object. 
  137.      */ 
  138.     public function prepare_item_for_response( $post_type, $request ) { 
  139.         $taxonomies = wp_list_filter( get_object_taxonomies( $post_type->name, 'objects' ), array( 'show_in_rest' => true ) ); 
  140.         $taxonomies = wp_list_pluck( $taxonomies, 'name' ); 
  141.         $base = ! empty( $post_type->rest_base ) ? $post_type->rest_base : $post_type->name; 
  142.         $data = array( 
  143.             'capabilities' => $post_type->cap,  
  144.             'description' => $post_type->description,  
  145.             'hierarchical' => $post_type->hierarchical,  
  146.             'labels' => $post_type->labels,  
  147.             'name' => $post_type->label,  
  148.             'slug' => $post_type->name,  
  149.             'taxonomies' => array_values( $taxonomies ),  
  150.             'rest_base' => $base,  
  151.  ); 
  152.         $context = ! empty( $request['context'] ) ? $request['context'] : 'view'; 
  153.         $data = $this->add_additional_fields_to_object( $data, $request ); 
  154.         $data = $this->filter_response_by_context( $data, $context ); 
  155.  
  156.         // Wrap the data in a response object. 
  157.         $response = rest_ensure_response( $data ); 
  158.  
  159.         $response->add_links( array( 
  160.             'collection' => array( 
  161.                 'href' => rest_url( sprintf( '%s/%s', $this->namespace, $this->rest_base ) ),  
  162.  ),  
  163.             'https://api.w.org/items' => array( 
  164.                 'href' => rest_url( sprintf( 'wp/v2/%s', $base ) ),  
  165.  ),  
  166.  ) ); 
  167.  
  168.         /** 
  169.          * Filters a post type returned from the API. 
  170.          * 
  171.          * Allows modification of the post type data right before it is returned. 
  172.          * 
  173.          * @since 4.7.0 
  174.          * 
  175.          * @param WP_REST_Response $response The response object. 
  176.          * @param object           $item     The original post type object. 
  177.          * @param WP_REST_Request  $request  Request used to generate the response. 
  178.          */ 
  179.         return apply_filters( 'rest_prepare_post_type', $response, $post_type, $request ); 
  180.     } 
  181.  
  182.     /** 
  183.      * Retrieves the post type's schema, conforming to JSON Schema. 
  184.      * 
  185.      * @since 4.7.0 
  186.      * @access public 
  187.      * 
  188.      * @return array Item schema data. 
  189.      */ 
  190.     public function get_item_schema() { 
  191.         $schema = array( 
  192.             '$schema' => 'http://json-schema.org/schema#',  
  193.             'title' => 'type',  
  194.             'type' => 'object',  
  195.             'properties' => array( 
  196.                 'capabilities' => array( 
  197.                     'description' => __( 'All capabilities used by the post type.' ),  
  198.                     'type' => 'object',  
  199.                     'context' => array( 'edit' ),  
  200.                     'readonly' => true,  
  201.  ),  
  202.                 'description' => array( 
  203.                     'description' => __( 'A human-readable description of the post type.' ),  
  204.                     'type' => 'string',  
  205.                     'context' => array( 'view', 'edit' ),  
  206.                     'readonly' => true,  
  207.  ),  
  208.                 'hierarchical' => array( 
  209.                     'description' => __( 'Whether or not the post type should have children.' ),  
  210.                     'type' => 'boolean',  
  211.                     'context' => array( 'view', 'edit' ),  
  212.                     'readonly' => true,  
  213.  ),  
  214.                 'labels' => array( 
  215.                     'description' => __( 'Human-readable labels for the post type for various contexts.' ),  
  216.                     'type' => 'object',  
  217.                     'context' => array( 'edit' ),  
  218.                     'readonly' => true,  
  219.  ),  
  220.                 'name' => array( 
  221.                     'description' => __( 'The title for the post type.' ),  
  222.                     'type' => 'string',  
  223.                     'context' => array( 'view', 'edit', 'embed' ),  
  224.                     'readonly' => true,  
  225.  ),  
  226.                 'slug' => array( 
  227.                     'description' => __( 'An alphanumeric identifier for the post type.' ),  
  228.                     'type' => 'string',  
  229.                     'context' => array( 'view', 'edit', 'embed' ),  
  230.                     'readonly' => true,  
  231.  ),  
  232.                 'taxonomies' => array( 
  233.                     'description' => __( 'Taxonomies associated with post type.' ),  
  234.                     'type' => 'array',  
  235.                     'items' => array( 
  236.                         'type' => 'string',  
  237.  ),  
  238.                     'context' => array( 'view', 'edit' ),  
  239.                     'readonly' => true,  
  240.  ),  
  241.                 'rest_base' => array( 
  242.                     'description' => __( 'REST base route for the post type.' ),  
  243.                     'type' => 'string',  
  244.                     'context' => array( 'view', 'edit', 'embed' ),  
  245.                     'readonly' => true,  
  246.  ),  
  247.  ),  
  248.  ); 
  249.         return $this->add_additional_fields_schema( $schema ); 
  250.     } 
  251.  
  252.     /** 
  253.      * Retrieves the query params for collections. 
  254.      * 
  255.      * @since 4.7.0 
  256.      * @access public 
  257.      * 
  258.      * @return array Collection parameters. 
  259.      */ 
  260.     public function get_collection_params() { 
  261.         return array( 
  262.             'context' => $this->get_context_param( array( 'default' => 'view' ) ),  
  263.  ); 
  264.     } 
  265.  
  266. }