418 lines
9.2 KiB
PHP
418 lines
9.2 KiB
PHP
<?php
|
|
namespace Elementor\Data;
|
|
|
|
use Elementor\Core\Base\Module as BaseModule;
|
|
use Elementor\Data\Base\Processor;
|
|
|
|
if ( ! defined( 'ABSPATH' ) ) {
|
|
exit; // Exit if accessed directly
|
|
}
|
|
|
|
class Manager extends BaseModule {
|
|
|
|
const ROOT_NAMESPACE = 'elementor';
|
|
|
|
const REST_BASE = '';
|
|
|
|
const VERSION = '1';
|
|
|
|
/**
|
|
* @var \WP_REST_Server
|
|
*/
|
|
private $server;
|
|
|
|
/**
|
|
* @var boolean
|
|
*/
|
|
private $is_internal = false;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
private $cache = [];
|
|
|
|
/**
|
|
* Loaded controllers.
|
|
*
|
|
* @var \Elementor\Data\Base\Controller[]
|
|
*/
|
|
public $controllers = [];
|
|
|
|
/**
|
|
* Loaded command(s) format.
|
|
*
|
|
* @var string[]
|
|
*/
|
|
public $command_formats = [];
|
|
|
|
/**
|
|
* Fix issue with 'Potentially polymorphic call. The code may be inoperable depending on the actual class instance passed as the argument.'.
|
|
*
|
|
* @return \Elementor\Core\Base\Module|\Elementor\Data\Manager
|
|
*/
|
|
public static function instance() {
|
|
return ( parent::instance() );
|
|
}
|
|
|
|
public function __construct() {
|
|
add_action( 'rest_api_init', [ $this, 'register_rest_error_handler' ] );
|
|
}
|
|
|
|
public function get_name() {
|
|
return 'data-manager';
|
|
}
|
|
|
|
/**
|
|
* @return \Elementor\Data\Base\Controller[]
|
|
*/
|
|
public function get_controllers() {
|
|
return $this->controllers;
|
|
}
|
|
|
|
private function get_cache( $key ) {
|
|
return self::get_items( $this->cache, $key );
|
|
}
|
|
|
|
private function set_cache( $key, $value ) {
|
|
$this->cache[ $key ] = $value;
|
|
}
|
|
|
|
/**
|
|
* Register controller.
|
|
*
|
|
* @param string $controller_class_name
|
|
*
|
|
* @return \Elementor\Data\Base\Controller
|
|
*/
|
|
public function register_controller( $controller_class_name ) {
|
|
$controller_instance = new $controller_class_name();
|
|
|
|
return $this->register_controller_instance( $controller_instance );
|
|
}
|
|
|
|
/**
|
|
* Register controller instance.
|
|
*
|
|
* @param \Elementor\Data\Base\Controller $controller_instance
|
|
*
|
|
* @return \Elementor\Data\Base\Controller
|
|
*/
|
|
public function register_controller_instance( $controller_instance ) {
|
|
// TODO: Validate instance.
|
|
|
|
$this->controllers[ $controller_instance->get_name() ] = $controller_instance;
|
|
|
|
return $controller_instance;
|
|
}
|
|
|
|
/**
|
|
* Register endpoint format.
|
|
*
|
|
* @param string $command
|
|
* @param string $format
|
|
*
|
|
*/
|
|
public function register_endpoint_format( $command, $format ) {
|
|
$this->command_formats[ $command ] = rtrim( $format, '/' );
|
|
}
|
|
|
|
public function register_rest_error_handler() {
|
|
if ( ! $this->is_internal() ) {
|
|
$logger_manager = \Elementor\Core\Logger\Manager::instance();
|
|
$logger_manager->register_error_handler();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find controller instance.
|
|
*
|
|
* By given command name.
|
|
*
|
|
* @param string $command
|
|
*
|
|
* @return false|\Elementor\Data\Base\Controller
|
|
*/
|
|
public function find_controller_instance( $command ) {
|
|
$command_parts = explode( '/', $command );
|
|
$assumed_command_parts = [];
|
|
|
|
foreach ( $command_parts as $command_part ) {
|
|
$assumed_command_parts [] = $command_part;
|
|
|
|
foreach ( $this->controllers as $controller_name => $controller ) {
|
|
$assumed_command = implode( '/', $assumed_command_parts );
|
|
|
|
if ( $assumed_command === $controller_name ) {
|
|
return $controller;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Command extract args.
|
|
*
|
|
* @param string $command
|
|
* @param array $args
|
|
*
|
|
* @return \stdClass
|
|
*/
|
|
public function command_extract_args( $command, $args = [] ) {
|
|
$result = new \stdClass();
|
|
$result->command = $command;
|
|
$result->args = $args;
|
|
|
|
if ( false !== strpos( $command, '?' ) ) {
|
|
$command_parts = explode( '?', $command );
|
|
$pure_command = $command_parts[0];
|
|
$query_string = $command_parts[1];
|
|
|
|
parse_str( $query_string, $temp );
|
|
|
|
$result->command = rtrim( $pure_command, '/' );
|
|
$result->args = array_merge( $args, $temp );
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Command to endpoint.
|
|
*
|
|
* Format is required otherwise $command will returned.
|
|
*
|
|
* @param string $command
|
|
* @param string $format
|
|
* @param array $args
|
|
*
|
|
* @return string endpoint
|
|
*/
|
|
public function command_to_endpoint( $command, $format, $args ) {
|
|
$endpoint = $command;
|
|
|
|
if ( $format ) {
|
|
$formatted = $format;
|
|
|
|
array_walk( $args, function ( $val, $key ) use ( &$formatted ) {
|
|
$formatted = str_replace( '{' . $key . '}', $val, $formatted );
|
|
} );
|
|
|
|
// Remove remaining format if not requested via `$args`.
|
|
if ( strstr( $formatted, '/{' ) ) {
|
|
/**
|
|
* Example:
|
|
* $command = 'example/documents';
|
|
* $format = 'example/documents/{document_id}/elements/{element_id}';
|
|
* $formatted = 'example/documents/1618/elements/{element_id}';
|
|
* Result:
|
|
* $formatted = 'example/documents/1618/elements';
|
|
*/
|
|
$formatted = substr( $formatted, 0, strpos( $formatted, '/{' ) );
|
|
}
|
|
|
|
$endpoint = $formatted;
|
|
}
|
|
|
|
return $endpoint;
|
|
}
|
|
|
|
/**
|
|
* Run server.
|
|
*
|
|
* Init WordPress reset api.
|
|
*
|
|
* @return \WP_REST_Server
|
|
*/
|
|
public function run_server() {
|
|
/**
|
|
* If run_server() called means, that rest api is simulated from the backend.
|
|
*/
|
|
$this->is_internal = true;
|
|
|
|
if ( ! $this->server ) {
|
|
// Remove all 'rest_api_init' actions.
|
|
remove_all_actions( 'rest_api_init' );
|
|
|
|
// Call custom reset api loader.
|
|
do_action( 'elementor_rest_api_before_init' );
|
|
|
|
$this->server = rest_get_server(); // Init API.
|
|
}
|
|
|
|
return $this->server;
|
|
}
|
|
|
|
/**
|
|
* Kill server.
|
|
*
|
|
* Free server and controllers.
|
|
*/
|
|
public function kill_server() {
|
|
global $wp_rest_server;
|
|
|
|
$this->controllers = [];
|
|
$this->command_formats = [];
|
|
$this->server = false;
|
|
$this->is_internal = false;
|
|
$this->cache = [];
|
|
$wp_rest_server = false;
|
|
}
|
|
|
|
/**
|
|
* Run processor.
|
|
*
|
|
* @param \Elementor\Data\Base\Processor $processor
|
|
* @param array $data
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function run_processor( $processor, $data ) {
|
|
if ( call_user_func_array( [ $processor, 'get_conditions' ], $data ) ) {
|
|
return call_user_func_array( [ $processor, 'apply' ], $data );
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Run processors.
|
|
*
|
|
* Filter them by class.
|
|
*
|
|
* @param \Elementor\Data\Base\Processor[] $processors
|
|
* @param string $filter_by_class
|
|
* @param array $data
|
|
*
|
|
* @return false|array
|
|
*/
|
|
public function run_processors( $processors, $filter_by_class, $data ) {
|
|
foreach ( $processors as $processor ) {
|
|
if ( $processor instanceof $filter_by_class ) {
|
|
if ( Processor\Before::class === $filter_by_class ) {
|
|
$this->run_processor( $processor, $data );
|
|
} elseif ( Processor\After::class === $filter_by_class ) {
|
|
$result = $this->run_processor( $processor, $data );
|
|
if ( $result ) {
|
|
$data[1] = $result;
|
|
}
|
|
} else {
|
|
// TODO: error
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return isset( $data[1] ) ? $data[1] : false;
|
|
}
|
|
|
|
/**
|
|
* Run request.
|
|
*
|
|
* Simulate rest API from within the backend.
|
|
* Use args as query.
|
|
*
|
|
* @param string $endpoint
|
|
* @param array $args
|
|
* @param string $method
|
|
*
|
|
* @return \WP_REST_Response
|
|
*/
|
|
private function run_request( $endpoint, $args, $method ) {
|
|
$this->run_server();
|
|
|
|
$endpoint = '/' . self::ROOT_NAMESPACE . '/v' . self::VERSION . '/' . $endpoint;
|
|
|
|
// Run reset api.
|
|
$request = new \WP_REST_Request( $method, $endpoint );
|
|
|
|
if ( 'GET' === $method ) {
|
|
$request->set_query_params( $args );
|
|
} else {
|
|
$request->set_body_params( $args );
|
|
}
|
|
|
|
return rest_do_request( $request );
|
|
}
|
|
|
|
/**
|
|
* Run endpoint.
|
|
*
|
|
* Wrapper for `$this->run_request` return `$response->getData()` instead of `$response`.
|
|
*
|
|
* @param string $endpoint
|
|
* @param array $args
|
|
* @param string $method
|
|
*
|
|
* @return array
|
|
*/
|
|
public function run_endpoint( $endpoint, $args = [], $method = 'GET' ) {
|
|
$response = $this->run_request( $endpoint, $args, $method );
|
|
|
|
return $response->get_data();
|
|
}
|
|
|
|
/**
|
|
* Run ( simulated reset api ).
|
|
*
|
|
* Do:
|
|
* Init reset server.
|
|
* Run before processors.
|
|
* Run command as reset api endpoint from internal.
|
|
* Run after processors.
|
|
*
|
|
* @param string $command
|
|
* @param array $args
|
|
* @param string $method
|
|
*
|
|
* @return array|false processed result
|
|
*/
|
|
public function run( $command, $args = [], $method = 'GET' ) {
|
|
$key = crc32( $command . '-' . wp_json_encode( $args ) . '-' . $method );
|
|
$cache = $this->get_cache( $key );
|
|
|
|
if ( $cache ) {
|
|
return $cache;
|
|
}
|
|
|
|
$this->run_server();
|
|
|
|
$controller_instance = $this->find_controller_instance( $command );
|
|
|
|
if ( ! $controller_instance ) {
|
|
$this->set_cache( $key, [] );
|
|
return [];
|
|
}
|
|
|
|
$extracted_command = $this->command_extract_args( $command, $args );
|
|
$command = $extracted_command->command;
|
|
$args = $extracted_command->args;
|
|
|
|
$format = isset( $this->command_formats[ $command ] ) ? $this->command_formats[ $command ] : false;
|
|
|
|
$command_processors = $controller_instance->get_processors( $command );
|
|
|
|
$endpoint = $this->command_to_endpoint( $command, $format, $args );
|
|
|
|
$this->run_processors( $command_processors, Processor\Before::class, [ $args ] );
|
|
|
|
$response = $this->run_request( $endpoint, $args, $method );
|
|
$result = $response->get_data();
|
|
|
|
if ( $response->is_error() ) {
|
|
$this->set_cache( $key, [] );
|
|
return [];
|
|
}
|
|
|
|
$result = $this->run_processors( $command_processors, Processor\After::class, [ $args, $result ] );
|
|
|
|
$this->set_cache( $key, $result );
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function is_internal() {
|
|
return $this->is_internal;
|
|
}
|
|
}
|