Example #1
0
 /**
  * Sets default Api routes
  *
  * @return void
  */
 public function setDefaultRoutes()
 {
     // Hello World route
     $this->api->get('/', function () {
         return array('Hello World');
     });
     // Get all registered post types
     $post_types = get_post_types(array(), 'objects');
     //////////////////////////
     // Add /search endpoint //
     //////////////////////////
     $this->api->get("search(/)(:keywords)", function ($keywords = null) {
         // Override context
         ContextManager::getInstance()->overrideCurrent('api/search');
         // Get all registered post types
         $post_types = get_post_types(array(), 'objects');
         // Default query args
         $default_query = ['type' => []];
         // Add all publicly queryable types to search results
         if ($post_types) {
             foreach ($post_types as $type) {
                 if ($type->name == 'page' || $type->publicly_queryable) {
                     $default_query['type'][] = $type->name;
                 }
             }
         }
         // Enable developers to modify $default_query for this resource
         $default_query = apply_filters("bebop:api:search:default_query", $default_query);
         // Capture 'post_type' argument
         if (isset($_GET['post_type'])) {
             $_GET['type'] = $_GET['post_type'];
             unset($_GET['post_type']);
         }
         // Merge default query args with user query args
         $query = array_merge($default_query, $_GET);
         // Add keywords to query
         if ($keywords) {
             $query['s'] = $keywords;
         }
         // Enable developers to modify final query for this resource
         $query = apply_filters("bebop:api:search:query", $query);
         // Get results
         $response = Db::wpQuery($query)->setOption('with_meta', true)->execute();
         // Apply model modifications for each post type
         if ($response['items']) {
             foreach ($response['items'] as $index => $post) {
                 if (ModelFactory::canManufacture($post->post_type)) {
                     $response['items'][$index] = ModelFactory::create($post->post_type, array($post));
                 }
             }
         }
         // Enable developers to modify response for this resource
         $response = apply_filters("bebop:api:search:response", $response);
         // Return response
         return $response;
     });
     /////////////////////////////////////////////////
     // Add endpoints for all available posts types //
     /////////////////////////////////////////////////
     foreach ($post_types as $slug => $post_type) {
         if ($post_type->public) {
             $resource_name = Utils::slugify($post_type->labels->name);
             // Add post resource
             $this->api->get("{$resource_name}(/)(:id)", function ($id = null) use($post_type, $resource_name) {
                 if (is_numeric($id)) {
                     // Override context
                     ContextManager::getInstance()->overrideCurrent('api/single/' . $resource_name);
                     $post = get_post($id);
                     if ($post instanceof \WP_Post) {
                         if (ModelFactory::canManufacture($post->post_type)) {
                             $post = ModelFactory::create($post->post_type, array($post));
                         }
                         $response = $post;
                     }
                 } else {
                     // Override context
                     ContextManager::getInstance()->overrideCurrent('api/archive/' . $resource_name);
                     if (isset($_GET['type'])) {
                         unset($_GET['type']);
                     }
                     if ($resource_name == 'media') {
                         if (isset($_GET['status'])) {
                             unset($_GET['status']);
                         }
                         $_GET['post_type'] = 'attachment';
                         $_GET['post_status'] = 'inherit';
                     } else {
                         $_GET['post_type'] = $post_type->name;
                     }
                     $response = Db::wpQuery($_GET)->setOption('with_meta', true)->execute();
                     if ($response['items']) {
                         foreach ($response['items'] as $index => $post) {
                             if (ModelFactory::canManufacture($post->post_type)) {
                                 $response['items'][$index] = ModelFactory::create($post->post_type, array($post));
                             }
                         }
                     }
                 }
                 // Enable developers to modify response for target resource
                 $response = apply_filters("bebop:api:{$resource_name}:response", $response);
                 // Return response
                 return $response;
             });
             /////////////////////////////////////
             // Get all or individual post meta //
             /////////////////////////////////////
             $this->api->get("{$resource_name}/:post_id/meta/:meta_key(/)(:meta_id)", function ($post_id, $meta_key, $meta_id = null) use($post_type, $resource_name) {
                 // Throw error if post do not exist
                 if (!get_post($post_id) instanceof \WP_Post) {
                     throw new ApiException("Target entry do not exist", 404);
                 }
                 // Get meta data
                 $post_meta = new ObjectMeta('post', $post_id, array('projection' => $this->postmeta_projection));
                 $response = $meta_id ? $post_meta->get($meta_key, $meta_id) : $post_meta->getAll($meta_key);
                 // Enable developers to modify response
                 $response = apply_filters("bebop:api:postmeta:{$meta_key}:response", $response, $post_id);
                 // Enable developers to modify response
                 $response = apply_filters('bebop:api:postmeta:response', $response, $meta_key, $post_id);
                 // Return response
                 return $response;
             });
             /////////////////////////////
             // Create single post meta //
             /////////////////////////////
             $this->api->post("{$resource_name}/:post_id/meta/:meta_key(/)", function ($post_id, $meta_key) {
                 // Check if current user can edit the target post
                 if (!current_user_can('edit_post', $post_id)) {
                     throw new ApiException("You cannot edit the target entry", 403);
                 }
                 // Get request body
                 $data = json_decode($this->api->router()->request()->getBody(), true);
                 // Throw error if payload is null
                 if (is_null($data)) {
                     throw new ApiException("You cannot send an empty request body", 400);
                 }
                 // Defined storage method
                 $storage_method = isset($_GET['storage_method']) ? $_GET['storage_method'] : 'json';
                 // Check storage type
                 if (!in_array($storage_method, array('json', 'serialize'))) {
                     throw new ApiException("Storage method needs to be either 'json' or 'serialize'", 400);
                 }
                 // Throw error if post do not exist
                 if (!get_post($post_id) instanceof \WP_Post) {
                     throw new ApiException("Target entry do not exist", 404);
                 }
                 // Instantiate PostMeta object
                 $post_meta = new ObjectMeta('post', $post_id, array('projection' => $this->postmeta_projection));
                 // Add new meta row
                 $new_item = $post_meta->add($meta_key, $data, $storage_method);
                 // Throw error if it was not able to create new postmeta item
                 if (!$new_item) {
                     throw new ApiException("Failed to create new postmeta item", 500);
                 }
                 // Return response
                 return $new_item;
             });
             /////////////////////////////
             // Update single post meta //
             /////////////////////////////
             $this->api->put("{$resource_name}/:post_id/meta/:meta_key/:meta_id(/)", function ($post_id, $meta_key, $meta_id) {
                 // Check if current user can edit the target post
                 if (!current_user_can('edit_post', $post_id)) {
                     throw new ApiException("You cannot edit the target entry", 403);
                 }
                 // Get request body
                 $data = json_decode($this->api->router()->request()->getBody(), true);
                 // Throw error if payload is null
                 if (is_null($data)) {
                     throw new ApiException("You cannot send an empty request body", 400);
                 }
                 // Defined storage method
                 $storage_method = isset($_GET['storage_method']) ? $_GET['storage_method'] : 'json';
                 // Check storage type
                 if (!in_array($storage_method, array('json', 'serialize'))) {
                     throw new ApiException("Storage method needs to be either 'json' or 'serialize'", 400);
                 }
                 // Throw error if post do not exist
                 if (!get_post($post_id) instanceof \WP_Post) {
                     throw new ApiException("Target entry do not exist", 404);
                 }
                 // Instantiate PostMeta object
                 $post_meta = new ObjectMeta('post', $post_id, array('projection' => $this->postmeta_projection));
                 // Update Meta
                 $updated_item = $post_meta->update($meta_key, $meta_id, $data, $storage_method);
                 // Throw error if it was not able to update the target postmeta item
                 if (!$updated_item) {
                     throw new ApiException("Failed to update postmeta item", 500);
                 }
                 // Return updated item
                 return $updated_item;
             });
             /////////////////////////////
             // Delete single post meta //
             /////////////////////////////
             $this->api->delete("{$resource_name}/:post_id/meta/:meta_key/:meta_id(/)", function ($post_id, $meta_key, $meta_id) use($post_type, $resource_name) {
                 // Check if current user can edit the target post
                 if (!current_user_can('edit_post', $post_id)) {
                     throw new ApiException("You cannot edit the target entry", 403);
                 }
                 // Throw error if post do not exist
                 if (!get_post($post_id) instanceof \WP_Post) {
                     throw new ApiException("Target entry do not exist", 404);
                 }
                 // Instantiate PostMeta object
                 $post_meta = new ObjectMeta('post', $post_id, array('projection' => $this->postmeta_projection));
                 // Delete post meta
                 $remaining_items = $post_meta->delete($meta_key, $meta_id);
                 // Return remaining items
                 return $remaining_items;
             });
         }
     }
     // Add endpoint to inform about available endpoints
     $this->api->get("_resources(/)", function () use($post_types) {
         if (!current_user_can('manage_options')) {
             $this->api->router()->slim()->halt(403, json_encode(array('error' => array('status' => 403, 'message' => "You're not an authorized user."))));
             exit;
         }
         $base_url = '/' . $this->api->getBaseUrl();
         // Loop through all defined routes
         foreach ($this->api->routes()->getAll() as $route) {
             $resources[] = array('method' => strtoupper($route->getMethod()), 'endpoint' => $base_url . ltrim($route->getPath(), '/'));
         }
         // Return resources
         return $resources;
     });
     return $this;
 }
Example #2
0
 /**
  * Returns entries by ID
  * 
  * @param  mixed $ids        Single ID or array of IDs
  * @param  bool  $keep_order True if posts order should match the order of $ids, false otherwise
  * @return mixed             Single object or array of objects
  */
 public static function find($ids = null, $keep_order = true)
 {
     // Make sure we have a clean query object to be used
     static::__resetQuery();
     // Setting placeholder for data to return
     $data = null;
     // Get current context global $post
     if (is_null($ids)) {
         if (ContextManager::getInstance()->is('single')) {
             global $post;
             return static::__applyModelMods($post);
         }
     } else {
         // Get model configuration instance
         $instance = static::__getInstance();
         // Set post type argument
         $instance->query->postType(static::$__type);
         // Change status to inherit on attachments
         if (static::$__type == 'attachment') {
             $instance->query->status('inherit');
         }
         // Get results
         $data = $instance->query->find($ids, $keep_order);
         if ($data) {
             if (is_object($data)) {
                 $data = static::__applyModelMods($data);
             } elseif (is_array($data)) {
                 foreach ($data as $key => $post) {
                     $data[$key] = static::__applyModelMods($post);
                 }
             }
         }
     }
     return $data;
 }
Example #3
0
 /**
  * Returns the context manager
  * 
  */
 public static function Context()
 {
     return ContextManager::getInstance();
 }