관리-도구

편집 파일: class-kkart-api-server.php

<?php
/**
 * Kkart API
 *
 * Handles REST API requests
 *
 * This class and related code (JSON response handler, resource classes) are based on WP-API v0.6 (https://github.com/WP-API/WP-API)
 * Many thanks to Ryan McCue and any other contributors!
 *
 * @author   WooThemes
 * @category API
 * @package  Kkart\RestApi
 * @since    2.1
 */

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly
}

require_once KKART_ADMIN_DIR . 'includes/admin.php';

class KKART_API_Server {

const METHOD_GET    = 1;
	const METHOD_POST   = 2;
	const METHOD_PUT    = 4;
	const METHOD_PATCH  = 8;
	const METHOD_DELETE = 16;

/**
	 * Does the endpoint accept a raw request body?
	 */
	const ACCEPT_RAW_DATA = 64;

/** Does the endpoint accept a request body? (either JSON or XML) */
	const ACCEPT_DATA = 128;

/**
	 * Should we hide this endpoint from the index?
	 */
	const HIDDEN_ENDPOINT = 256;

/**
	 * Map of HTTP verbs to constants
	 * @var array
	 */
	public static $method_map = array(
		'HEAD'   => self::METHOD_GET,
		'GET'    => self::METHOD_GET,
		'POST'   => self::METHOD_POST,
		'PUT'    => self::METHOD_PUT,
		'PATCH'  => self::METHOD_PATCH,
		'DELETE' => self::METHOD_DELETE,
	);

/**
	 * Requested path (relative to the API root, wp-json.php)
	 *
	 * @var string
	 */
	public $path = '';

/**
	 * Requested method (GET/HEAD/POST/PUT/PATCH/DELETE)
	 *
	 * @var string
	 */
	public $method = 'HEAD';

/**
	 * Request parameters
	 *
	 * This acts as an abstraction of the superglobals
	 * (GET => $_GET, POST => $_POST)
	 *
	 * @var array
	 */
	public $params = array( 'GET' => array(), 'POST' => array() );

/**
	 * Request headers
	 *
	 * @var array
	 */
	public $headers = array();

/**
	 * Request files (matches $_FILES)
	 *
	 * @var array
	 */
	public $files = array();

/**
	 * Request/Response handler, either JSON by default
	 * or XML if requested by client
	 *
	 * @var KKART_API_Handler
	 */
	public $handler;

/**
	 * Setup class and set request/response handler
	 *
	 * @since 2.1
	 * @param $path
	 */
	public function __construct( $path ) {

if ( empty( $path ) ) {
			if ( isset( $_SERVER['PATH_INFO'] ) ) {
				$path = $_SERVER['PATH_INFO'];
			} else {
				$path = '/';
			}
		}

$this->path           = $path;
		$this->method         = $_SERVER['REQUEST_METHOD'];
		$this->params['GET']  = $_GET;
		$this->params['POST'] = $_POST;
		$this->headers        = $this->get_headers( $_SERVER );
		$this->files          = $_FILES;

// Compatibility for clients that can't use PUT/PATCH/DELETE
		if ( isset( $_GET['_method'] ) ) {
			$this->method = strtoupper( $_GET['_method'] );
		} elseif ( isset( $_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'] ) ) {
			$this->method = $_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'];
		}

// load response handler
		$handler_class = apply_filters( 'kkart_api_default_response_handler', 'KKART_API_JSON_Handler', $this->path, $this );

$this->handler = new $handler_class();
	}

/**
	 * Check authentication for the request
	 *
	 * @since 2.1
	 * @return WP_User|WP_Error WP_User object indicates successful login, WP_Error indicates unsuccessful login
	 */
	public function check_authentication() {

// allow plugins to remove default authentication or add their own authentication
		$user = apply_filters( 'kkart_api_check_authentication', null, $this );

if ( is_a( $user, 'WP_User' ) ) {

// API requests run under the context of the authenticated user
			wp_set_current_user( $user->ID );

} elseif ( ! is_wp_error( $user ) ) {

// WP_Errors are handled in serve_request()
			$user = new WP_Error( 'kkart_api_authentication_error', __( 'Invalid authentication method', 'kkart' ), array( 'code' => 500 ) );

}

return $user;
	}

/**
	 * Convert an error to an array
	 *
	 * This iterates over all error codes and messages to change it into a flat
	 * array. This enables simpler client behaviour, as it is represented as a
	 * list in JSON rather than an object/map
	 *
	 * @since 2.1
	 * @param WP_Error $error
	 * @return array List of associative arrays with code and message keys
	 */
	protected function error_to_array( $error ) {
		$errors = array();
		foreach ( (array) $error->errors as $code => $messages ) {
			foreach ( (array) $messages as $message ) {
				$errors[] = array( 'code' => $code, 'message' => $message );
			}
		}

return array( 'errors' => $errors );
	}

/**
	 * Handle serving an API request
	 *
	 * Matches the current server URI to a route and runs the first matching
	 * callback then outputs a JSON representation of the returned value.
	 *
	 * @since 2.1
	 * @uses KKART_API_Server::dispatch()
	 */
	public function serve_request() {

do_action( 'kkart_api_server_before_serve', $this );

$this->header( 'Content-Type', $this->handler->get_content_type(), true );

// the API is enabled by default
		if ( ! apply_filters( 'kkart_api_enabled', true, $this ) || ( 'no' === get_option( 'kkart_api_enabled' ) ) ) {

$this->send_status( 404 );

echo $this->handler->generate_response( array( 'errors' => array( 'code' => 'kkart_api_disabled', 'message' => 'The Kkart API is disabled on this site' ) ) );

return;
		}

$result = $this->check_authentication();

// if authorization check was successful, dispatch the request
		if ( ! is_wp_error( $result ) ) {
			$result = $this->dispatch();
		}

// handle any dispatch errors
		if ( is_wp_error( $result ) ) {
			$data = $result->get_error_data();
			if ( is_array( $data ) && isset( $data['status'] ) ) {
				$this->send_status( $data['status'] );
			}

$result = $this->error_to_array( $result );
		}

// This is a filter rather than an action, since this is designed to be
		// re-entrant if needed
		$served = apply_filters( 'kkart_api_serve_request', false, $result, $this );

if ( ! $served ) {

if ( 'HEAD' === $this->method ) {
				return;
			}

echo $this->handler->generate_response( $result );
		}
	}

/**
	 * Retrieve the route map
	 *
	 * The route map is an associative array with path regexes as the keys. The
	 * value is an indexed array with the callback function/method as the first
	 * item, and a bitmask of HTTP methods as the second item (see the class
	 * constants).
	 *
	 * Each route can be mapped to more than one callback by using an array of
	 * the indexed arrays. This allows mapping e.g. GET requests to one callback
	 * and POST requests to another.
	 *
	 * Note that the path regexes (array keys) must have @ escaped, as this is
	 * used as the delimiter with preg_match()
	 *
	 * @since 2.1
	 * @return array `'/path/regex' => array( $callback, $bitmask )` or `'/path/regex' => array( array( $callback, $bitmask ), ...)`
	 */
	public function get_routes() {

// index added by default
		$endpoints = array(

'/' => array( array( $this, 'get_index' ), self::READABLE ),
		);

$endpoints = apply_filters( 'kkart_api_endpoints', $endpoints );

// Normalise the endpoints
		foreach ( $endpoints as $route => &$handlers ) {
			if ( count( $handlers ) <= 2 && isset( $handlers[1] ) && ! is_array( $handlers[1] ) ) {
				$handlers = array( $handlers );
			}
		}

return $endpoints;
	}

/**
	 * Match the request to a callback and call it
	 *
	 * @since 2.1
	 * @return mixed The value returned by the callback, or a WP_Error instance
	 */
	public function dispatch() {

switch ( $this->method ) {

case 'HEAD' :
			case 'GET' :
				$method = self::METHOD_GET;
				break;

case 'POST' :
				$method = self::METHOD_POST;
				break;

case 'PUT' :
				$method = self::METHOD_PUT;
				break;

case 'PATCH' :
				$method = self::METHOD_PATCH;
				break;

case 'DELETE' :
				$method = self::METHOD_DELETE;
				break;

default :
				return new WP_Error( 'kkart_api_unsupported_method', __( 'Unsupported request method', 'kkart' ), array( 'status' => 400 ) );
		}

foreach ( $this->get_routes() as $route => $handlers ) {
			foreach ( $handlers as $handler ) {
				$callback  = $handler[0];
				$supported = isset( $handler[1] ) ? $handler[1] : self::METHOD_GET;

if ( ! ( $supported & $method ) ) {
					continue;
				}

$match = preg_match( '@^' . $route . '$@i', urldecode( $this->path ), $args );

if ( ! $match ) {
					continue;
				}

if ( ! is_callable( $callback ) ) {
					return new WP_Error( 'kkart_api_invalid_handler', __( 'The handler for the route is invalid', 'kkart' ), array( 'status' => 500 ) );
				}

$args = array_merge( $args, $this->params['GET'] );
				if ( $method & self::METHOD_POST ) {
					$args = array_merge( $args, $this->params['POST'] );
				}
				if ( $supported & self::ACCEPT_DATA ) {
					$data = $this->handler->parse_body( $this->get_raw_data() );
					$args = array_merge( $args, array( 'data' => $data ) );
				} elseif ( $supported & self::ACCEPT_RAW_DATA ) {
					$data = $this->get_raw_data();
					$args = array_merge( $args, array( 'data' => $data ) );
				}

$args['_method']  = $method;
				$args['_route']   = $route;
				$args['_path']    = $this->path;
				$args['_headers'] = $this->headers;
				$args['_files']   = $this->files;

$args = apply_filters( 'kkart_api_dispatch_args', $args, $callback );

// Allow plugins to halt the request via this filter
				if ( is_wp_error( $args ) ) {
					return $args;
				}

$params = $this->sort_callback_params( $callback, $args );
				if ( is_wp_error( $params ) ) {
					return $params;
				}

return call_user_func_array( $callback, $params );
			}
		}

return new WP_Error( 'kkart_api_no_route', __( 'No route was found matching the URL and request method', 'kkart' ), array( 'status' => 404 ) );
	}

/**
	 * urldecode deep.
	 *
	 * @since  2.2
	 * @param  string|array $value Data to decode with urldecode.
	 *
	 * @return string|array        Decoded data.
	 */
	protected function urldecode_deep( $value ) {
		if ( is_array( $value ) ) {
			return array_map( array( $this, 'urldecode_deep' ), $value );
		} else {
			return urldecode( $value );
		}
	}

/**
	 * Sort parameters by order specified in method declaration
	 *
	 * Takes a callback and a list of available params, then filters and sorts
	 * by the parameters the method actually needs, using the Reflection API
	 *
	 * @since 2.2
	 *
	 * @param callable|array $callback the endpoint callback
	 * @param array $provided the provided request parameters
	 *
	 * @return array|WP_Error
	 */
	protected function sort_callback_params( $callback, $provided ) {
		if ( is_array( $callback ) ) {
			$ref_func = new ReflectionMethod( $callback[0], $callback[1] );
		} else {
			$ref_func = new ReflectionFunction( $callback );
		}

$wanted = $ref_func->getParameters();
		$ordered_parameters = array();

foreach ( $wanted as $param ) {
			if ( isset( $provided[ $param->getName() ] ) ) {
				// We have this parameters in the list to choose from
				if ( 'data' == $param->getName() ) {
					$ordered_parameters[] = $provided[ $param->getName() ];
					continue;
				}

$ordered_parameters[] = $this->urldecode_deep( $provided[ $param->getName() ] );
			} elseif ( $param->isDefaultValueAvailable() ) {
				// We don't have this parameter, but it's optional
				$ordered_parameters[] = $param->getDefaultValue();
			} else {
				// We don't have this parameter and it wasn't optional, abort!
				return new WP_Error( 'kkart_api_missing_callback_param', sprintf( __( 'Missing parameter %s', 'kkart' ), $param->getName() ), array( 'status' => 400 ) );
			}
		}

return $ordered_parameters;
	}

/**
	 * Get the site index.
	 *
	 * This endpoint describes the capabilities of the site.
	 *
	 * @since 2.3
	 * @return array Index entity
	 */
	public function get_index() {

// General site data
		$available = array(
			'store' => array(
				'name'        => get_option( 'blogname' ),
				'description' => get_option( 'blogdescription' ),
				'URL'         => get_option( 'siteurl' ),
				'kkart_version'  => KKART()->version,
				'version'     => KKART_API::VERSION,
				'routes'      => array(),
				'meta'        => array(
					'timezone'           => kkart_timezone_string(),
					'currency'           => get_kkart_currency(),
					'currency_format'    => get_kkart_currency_symbol(),
					'currency_position'  => get_option( 'kkart_currency_pos' ),
					'thousand_separator' => get_option( 'kkart_price_thousand_sep' ),
					'decimal_separator'  => get_option( 'kkart_price_decimal_sep' ),
					'price_num_decimals' => kkart_get_price_decimals(),
					'tax_included'       => kkart_prices_include_tax(),
					'weight_unit'        => get_option( 'kkart_weight_unit' ),
					'dimension_unit'     => get_option( 'kkart_dimension_unit' ),
					'ssl_enabled'        => ( 'yes' === get_option( 'kkart_force_ssl_checkout' ) || kkart_site_is_https() ),
					'permalinks_enabled' => ( '' !== get_option( 'permalink_structure' ) ),
					'generate_password'  => ( 'yes' === get_option( 'kkart_registration_generate_password' ) ),
					'links'              => array(
						'help' => 'https://kkart.github.io/kkart-rest-api-docs/',
					),
				),
			),
		);

// Find the available routes
		foreach ( $this->get_routes() as $route => $callbacks ) {
			$data = array();

$route = preg_replace( '#$\?P(<\w+?>).*?$#', '$1', $route );

foreach ( self::$method_map as $name => $bitmask ) {
				foreach ( $callbacks as $callback ) {
					// Skip to the next route if any callback is hidden
					if ( $callback[1] & self::HIDDEN_ENDPOINT ) {
						continue 3;
					}

if ( $callback[1] & $bitmask ) {
						$data['supports'][] = $name;
					}

if ( $callback[1] & self::ACCEPT_DATA ) {
						$data['accepts_data'] = true;
					}

// For non-variable routes, generate links
					if ( strpos( $route, '<' ) === false ) {
						$data['meta'] = array(
							'self' => get_kkart_api_url( $route ),
						);
					}
				}
			}

$available['store']['routes'][ $route ] = apply_filters( 'kkart_api_endpoints_description', $data );
		}

return apply_filters( 'kkart_api_index', $available );
	}

/**
	 * Send a HTTP status code
	 *
	 * @since 2.1
	 * @param int $code HTTP status
	 */
	public function send_status( $code ) {
		status_header( $code );
	}

/**
	 * Send a HTTP header
	 *
	 * @since 2.1
	 * @param string $key Header key
	 * @param string $value Header value
	 * @param boolean $replace Should we replace the existing header?
	 */
	public function header( $key, $value, $replace = true ) {
		header( sprintf( '%s: %s', $key, $value ), $replace );
	}

/**
	 * Send a Link header
	 *
	 * @internal The $rel parameter is first, as this looks nicer when sending multiple
	 *
	 * @link http://tools.ietf.org/html/rfc5988
	 * @link http://www.iana.org/assignments/link-relations/link-relations.xml
	 *
	 * @since 2.1
	 * @param string $rel Link relation. Either a registered type, or an absolute URL
	 * @param string $link Target IRI for the link
	 * @param array $other Other parameters to send, as an associative array
	 */
	public function link_header( $rel, $link, $other = array() ) {

$header = sprintf( '<%s>; rel="%s"', $link, esc_attr( $rel ) );

foreach ( $other as $key => $value ) {

if ( 'title' == $key ) {

$value = '"' . $value . '"';
			}

$header .= '; ' . $key . '=' . $value;
		}

$this->header( 'Link', $header, false );
	}

/**
	 * Send pagination headers for resources
	 *
	 * @since 2.1
	 * @param WP_Query|WP_User_Query|stdClass $query
	 */
	public function add_pagination_headers( $query ) {

// WP_User_Query
		if ( is_a( $query, 'WP_User_Query' ) ) {

$single      = count( $query->get_results() ) == 1;
			$total       = $query->get_total();

if ( $query->get( 'number' ) > 0 ) {
				$page = ( $query->get( 'offset' ) / $query->get( 'number' ) ) + 1;
				$total_pages = ceil( $total / $query->get( 'number' ) );
			} else {
				$page = 1;
				$total_pages = 1;
			}
		} elseif ( is_a( $query, 'stdClass' ) ) {
			$page        = $query->page;
			$single      = $query->is_single;
			$total       = $query->total;
			$total_pages = $query->total_pages;

// WP_Query
		} else {

$page        = $query->get( 'paged' );
			$single      = $query->is_single();
			$total       = $query->found_posts;
			$total_pages = $query->max_num_pages;
		}

if ( ! $page ) {
			$page = 1;
		}

$next_page = absint( $page ) + 1;

if ( ! $single ) {

// first/prev
			if ( $page > 1 ) {
				$this->link_header( 'first', $this->get_paginated_url( 1 ) );
				$this->link_header( 'prev', $this->get_paginated_url( $page -1 ) );
			}

// next
			if ( $next_page <= $total_pages ) {
				$this->link_header( 'next', $this->get_paginated_url( $next_page ) );
			}

// last
			if ( $page != $total_pages ) {
				$this->link_header( 'last', $this->get_paginated_url( $total_pages ) );
			}
		}

$this->header( 'X-KKART-Total', $total );
		$this->header( 'X-KKART-TotalPages', $total_pages );

do_action( 'kkart_api_pagination_headers', $this, $query );
	}

/**
	 * Returns the request URL with the page query parameter set to the specified page
	 *
	 * @since 2.1
	 * @param int $page
	 * @return string
	 */
	private function get_paginated_url( $page ) {

// remove existing page query param
		$request = remove_query_arg( 'page' );

// add provided page query param
		$request = urldecode( add_query_arg( 'page', $page, $request ) );

// get the home host
		$host = parse_url( get_home_url(), PHP_URL_HOST );

return set_url_scheme( "http://{$host}{$request}" );
	}

/**
	 * Retrieve the raw request entity (body)
	 *
	 * @since 2.1
	 * @return string
	 */
	public function get_raw_data() {
		// @codingStandardsIgnoreStart
		// $HTTP_RAW_POST_DATA is deprecated on PHP 5.6.
		if ( function_exists( 'phpversion' ) && version_compare( phpversion(), '5.6', '>=' ) ) {
			return file_get_contents( 'php://input' );
		}

global $HTTP_RAW_POST_DATA;

// A bug in PHP < 5.2.2 makes $HTTP_RAW_POST_DATA not set by default,
		// but we can do it ourself.
		if ( ! isset( $HTTP_RAW_POST_DATA ) ) {
			$HTTP_RAW_POST_DATA = file_get_contents( 'php://input' );
		}

return $HTTP_RAW_POST_DATA;
		// @codingStandardsIgnoreEnd
	}

/**
	 * Parse an RFC3339 datetime into a MySQl datetime
	 *
	 * Invalid dates default to unix epoch
	 *
	 * @since 2.1
	 * @param string $datetime RFC3339 datetime
	 * @return string MySQl datetime (YYYY-MM-DD HH:MM:SS)
	 */
	public function parse_datetime( $datetime ) {

// Strip millisecond precision (a full stop followed by one or more digits)
		if ( strpos( $datetime, '.' ) !== false ) {
			$datetime = preg_replace( '/\.\d+/', '', $datetime );
		}

// default timezone to UTC
		$datetime = preg_replace( '/[+-]\d+:+\d+$/', '+00:00', $datetime );

try {

$datetime = new DateTime( $datetime, new DateTimeZone( 'UTC' ) );

} catch ( Exception $e ) {

$datetime = new DateTime( '@0' );

}

return $datetime->format( 'Y-m-d H:i:s' );
	}

/**
	 * Format a unix timestamp or MySQL datetime into an RFC3339 datetime
	 *
	 * @since 2.1
	 * @param int|string $timestamp unix timestamp or MySQL datetime
	 * @param bool $convert_to_utc
	 * @param bool $convert_to_gmt Use GMT timezone.
	 * @return string RFC3339 datetime
	 */
	public function format_datetime( $timestamp, $convert_to_utc = false, $convert_to_gmt = false ) {
		if ( $convert_to_gmt ) {
			if ( is_numeric( $timestamp ) ) {
				$timestamp = date( 'Y-m-d H:i:s', $timestamp );
			}

$timestamp = get_gmt_from_date( $timestamp );
		}

if ( $convert_to_utc ) {
			$timezone = new DateTimeZone( kkart_timezone_string() );
		} else {
			$timezone = new DateTimeZone( 'UTC' );
		}

try {

if ( is_numeric( $timestamp ) ) {
				$date = new DateTime( "@{$timestamp}" );
			} else {
				$date = new DateTime( $timestamp, $timezone );
			}

// convert to UTC by adjusting the time based on the offset of the site's timezone
			if ( $convert_to_utc ) {
				$date->modify( -1 * $date->getOffset() . ' seconds' );
			}
		} catch ( Exception $e ) {

$date = new DateTime( '@0' );
		}

return $date->format( 'Y-m-d\TH:i:s\Z' );
	}

/**
	 * Extract headers from a PHP-style $_SERVER array
	 *
	 * @since 2.1
	 * @param array $server Associative array similar to $_SERVER
	 * @return array Headers extracted from the input
	 */
	public function get_headers( $server ) {
		$headers = array();
		// CONTENT_* headers are not prefixed with HTTP_
		$additional = array( 'CONTENT_LENGTH' => true, 'CONTENT_MD5' => true, 'CONTENT_TYPE' => true );

foreach ( $server as $key => $value ) {
			if ( strpos( $key, 'HTTP_' ) === 0 ) {
				$headers[ substr( $key, 5 ) ] = $value;
			} elseif ( isset( $additional[ $key ] ) ) {
				$headers[ $key ] = $value;
			}
		}

return $headers;
	}
}