balmet.com

class-api.php (35573B)

---

 <?php // phpcs:ignore WordPress.Files.FileName
 
 /**
  * Redux templates API class.
  *
  * @since   4.0.0
  * @package Redux Framework
  */
 
 namespace ReduxTemplates;
 
 use ReduxTemplates;
 use WP_Patterns_Registry;
 
 if ( ! defined( 'ABSPATH' ) ) {
 	exit; // Exit if accessed directly.
 }
 
 /**
  * ReduxTemplates API class.
  *
  * @since 4.0.0
  */
 class Api {
 
 	/**
 	 * Seconds to cache the local files.
 	 *
 	 * @var int
 	 */
 	private $cache_time = 24 * 3600; // 24 hours
 	/**
 	 * Timeout for requests.
 	 *
 	 * @var int
 	 */
 	private $timeout = 145;
 	/**
 	 * API URL.
 	 *
 	 * @var string
 	 */
 	protected $api_base_url = 'https://api.redux.io/';
 	/**
 	 * License API URL.
 	 *
 	 * @var string
 	 */
 	protected $license_base_url = 'https://redux.io/';
 	/**
 	 * Default headers array.
 	 *
 	 * @var array
 	 */
 	protected $default_request_headers = array();
 	/**
 	 * Filesystem object instance.
 	 *
 	 * @var Filesystem
 	 */
 	protected $filesystem;
 	/**
 	 * Cache folder location.
 	 *
 	 * @var string
 	 */
 	protected $cache_folder;
 
 	/**
 	 * Constructor.
 	 */
 	public function __construct() {
 
 		add_filter( 'redux_templates_api_headers', array( $this, 'request_verify' ) );
 		$this->default_request_headers = apply_filters( 'redux_templates_api_headers', $this->default_request_headers );
 
 		add_action( 'rest_api_init', array( $this, 'register_api_hooks' ), 0 );
 
 	}
 
 	/**
 	 * Get the filesystem.
 	 *
 	 * @return Filesystem
 	 */
 	private function get_filesystem() {
 		if ( empty( $this->filesystem ) ) {
 			$this->filesystem = \Redux_Filesystem::get_instance();
 
 		}
 
 		return $this->filesystem;
 	}
 
 	/**
 	 * Process the registered blocks from the library.
 	 *
 	 * @param array $parameters Array to be returned if no response, or to have data appended to.
 	 *
 	 * @return array Array of properly processed blocks and supported plugins.
 	 */
 	private function process_registered_blocks( $parameters ) {
 		$data = $this->api_cache_fetch( array(), array(), 'library.json' );
 
 		if ( empty( $data ) || ( ! empty( $data ) && ! isset( $data['plugins'] ) ) ) {
 			return $parameters;
 		}
 		$supported = ReduxTemplates\Supported_Plugins::instance();
 		$supported->init( $data['plugins'] );
 		$plugins           = $supported::get_plugins();
 		$installed_plugins = array();
 		if ( ! isset( $parameters['registered_blocks'] ) ) {
 			$parameters['registered_blocks'] = array();
 		}
 
 		foreach ( $plugins as $key => $value ) {
 			if ( isset( $value['version'] ) ) {
 				array_push( $installed_plugins, $key . '~' . $value['version'] );
 				$found_already = array_search( $key, $parameters['registered_blocks'], true );
 				if ( false !== $found_already ) {
 					unset( $parameters['registered_blocks'][ $found_already ] );
 				}
 				if ( isset( $value['namespace'] ) && $key !== $value['namespace'] ) {
 					$found = array_search( $value['namespace'], $parameters['registered_blocks'], true );
 					if ( false !== $found ) {
 						unset( $parameters['registered_blocks'][ $found ] );
 					}
 				}
 			}
 		}
 		$parameters['registered_blocks'] = array_values( array_merge( $installed_plugins, $parameters['registered_blocks'] ) );
 
 		return $parameters;
 	}
 
 	/**
 	 * Process the dependencies.
 	 *
 	 * @param array  $data Data array.
 	 * @param string $key  Key param.
 	 *
 	 * @return array Data array with dependencies outlined.
 	 */
 	private function process_dependencies( $data, $key ) {
 
 		foreach ( $data[ $key ] as $kk => $pp ) {
 			$debug = false;
 			// Add debug if statement if key matches here.
 
 			if ( isset( $pp['dependencies'] ) ) {
 				foreach ( $pp['dependencies'] as $dep ) {
 					if ( isset( $data['plugins'][ $dep ] ) ) {
 						if ( isset( $data['plugins'][ $dep ]['no_plugin'] ) || 'core' === $dep ) {
 							continue;
 						}
 						if ( isset( $data['plugins'][ $dep ]['free_slug'] ) ) {
 							if ( isset( $data['plugins'][ $data['plugins'][ $dep ]['free_slug'] ] ) ) {
 								$plugin = $data['plugins'][ $data['plugins'][ $dep ]['free_slug'] ];
 								if ( ! isset( $plugin['is_pro'] ) ) {
 									if ( ! isset( $data[ $key ][ $kk ]['proDependenciesMissing'] ) ) {
 										$data[ $key ][ $kk ]['proDependenciesMissing'] = array();
 									}
 									$data[ $key ][ $kk ]['proDependenciesMissing'][] = $dep;
 								}
 								if ( ! isset( $data[ $key ][ $kk ]['proDependencies'] ) ) {
 									$data[ $key ][ $kk ]['proDependencies'] = array();
 								}
 								$data[ $key ][ $kk ]['proDependencies'][] = $dep;
 							}
 						} else {
 							if ( ! isset( $data['plugins'][ $dep ]['version'] ) ) {
 								if ( ! isset( $data[ $key ][ $kk ]['installDependenciesMissing'] ) ) {
 									$data[ $key ][ $kk ]['installDependenciesMissing'] = array();
 								}
 								$data[ $key ][ $kk ]['installDependenciesMissing'][] = $dep;
 							}
 							if ( ! isset( $data[ $key ][ $kk ]['installDependencies'] ) ) {
 								$data[ $key ][ $kk ]['installDependencies'] = array();
 							}
 							$data[ $key ][ $kk ]['installDependencies'][] = $dep;
 						}
 					}
 				}
 			}
 
 			// Print the debug here if the key exists. Use `print_r( $data[ $key ][ $kk ] );exit();`.
 
 		}
 
 		return $data;
 
 	}
 
 	/**
 	 * Get the last cache time.
 	 *
 	 * @param string $abs_path Absolute path to a file.
 	 *
 	 * @return string|bool Last modified time.
 	 */
 	private function get_cache_time( $abs_path ) {
 		$filesystem    = $this->get_filesystem();
 		$last_modified = false;
 		if ( $filesystem->file_exists( $abs_path ) ) {
 			$last_modified = filemtime( $abs_path );
 		}
 
 		return $last_modified;
 	}
 
 	/**
 	 * Fetch from the cache if had.
 	 *
 	 * @param array  $parameters Absolute path to a file.
 	 * @param array  $config     Absolute path to a file.
 	 * @param string $path       URL path perform a request to a file.
 	 * @param bool   $cache_only Set to only fetch from the local cache.
 	 *
 	 * @return array Response and possibly the template if recovered.
 	 */
 	public function api_cache_fetch( $parameters, $config, $path, $cache_only = false ) {
 		$filesystem = $this->get_filesystem();
 
 		$this->cache_folder = trailingslashit( $filesystem->cache_folder ) . 'templates/';
 		if ( ! $filesystem->file_exists( $this->cache_folder ) ) {
 			$filesystem->mkdir( $this->cache_folder );
 		}
 
 		if ( strpos( $path, $this->cache_folder ) === false ) {
 			$path = $this->cache_folder . $path;
 		}
 		if ( ! $filesystem->file_exists( dirname( $path ) ) ) {
 			$filesystem->mkdir( dirname( $path ) );
 		}
 
 		$last_modified = file_exists( $path ) ? $this->get_cache_time( $path ) : false;
 
 		$use_cache = true;
 		if ( isset( $parameters['no_cache'] ) ) {
 			$use_cache = false;
 		}
 		if ( ! empty( $last_modified ) ) {
 			$config['headers']['Redux-Cache-Time'] = $last_modified;
 			if ( time() > $last_modified + $this->cache_time ) {
 				$use_cache = false;
 			}
 		}
 
 		if ( $cache_only ) {
 			$use_cache = true;
 		}
 
 		$data = array();
 		if ( file_exists( $path ) && $use_cache ) {
 			// phpcs:ignore WordPress.PHP.NoSilencedErrors
 			$data = @json_decode( $filesystem->get_contents( $path ), true );
 		}
 		// If somehow we got an invalid response, let's not persist it.
 		if ( isset( $data['message'] ) && false !== strpos( $data['message'], 'meta http-equiv="refresh" content="0;URL=' ) ) {
 			$data = false;
 		}
 
 		if ( $cache_only ) {
 			return $data;
 		}
 
 		if ( ! $use_cache && isset( $config['headers']['Redux-Cache-Time'] ) ) {
 			unset( $config['headers']['Redux-Cache-Time'] );
 		}
 
 		if ( empty( $data ) ) {
 
 			if ( isset( $parameters['registered_blocks'] ) ) {
 				$config['headers']['Redux-Registered-Blocks'] = implode( ',', $parameters['registered_blocks'] );
 			}
 
 			$results = $this->api_request( $config );
 
 			if ( ! empty( $results ) ) {
 				// phpcs:ignore WordPress.PHP.NoSilencedErrors
 				$data = @json_decode( $results, true );
 
 				if ( isset( $data['use_cache'] ) ) {
 					// phpcs:ignore WordPress.PHP.NoSilencedErrors
 					$data          = @json_decode( $filesystem->get_contents( $path ), true );
 					$data['cache'] = 'used';
 				} else {
 					if ( empty( $data ) ) {
 						$data = array( 'message' => $results );
 					}
 					if ( isset( $data['status'] ) && 'error' === $data['status'] ) {
 						wp_send_json_error( array( 'message' => $data['message'] ) );
 					}
 					$filesystem->put_contents( $path, wp_json_encode( $data ) );
 				}
 			} else {
 				wp_send_json_error( array( 'message' => __( 'API fetch failure.', 'redux-framework' ) ) );
 			}
 		}
 
 		if ( empty( $data ) ) {
 			// phpcs:ignore WordPress.PHP.NoSilencedErrors
 			$data = @json_decode( $filesystem->get_contents( $path ), true );
 			if ( $data ) {
 				$data['status']  = 'error';
 				$data['message'] = __( 'Fetching failed, used a cached version.', 'redux-framework' );
 			} else {
 				$data = array(
 					'message' => 'Error Fetching',
 				);
 			}
 		} else {
 			if ( ! $use_cache ) {
 				$data['cache'] = 'cleared';
 			}
 		}
 
 		return $data;
 	}
 
 	/**
 	 * Get library index. Support for library, collections, pages, sections all in a single request.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 *
 	 * @since 4.0.0
 	 */
 	public function get_index( \WP_REST_Request $request ) {
 
 		$parameters = $request->get_params();
 		$attributes = $request->get_attributes();
 
 		$type = $request->get_route();
 		$type = explode( '/', $type );
 		$type = end( $type );
 
 		if ( empty( $type ) ) {
 			wp_send_json_error( 'No type specified.' );
 		}
 
 		$config    = array(
 			'path' => 'library/',
 		);
 		$test_path = dirname( __FILE__ ) . '/library.json';
 
 		if ( file_exists( $test_path ) ) {
 			$data = json_decode( ReduxTemplates\Init::get_local_file_contents( $test_path ), true );
 		} else {
 			$parameters['no_cache'] = 1;
 			$data                   = $this->api_cache_fetch( $parameters, $config, 'library/' );
 		}
 
 		if ( isset( $data['plugins'] ) ) {
 			$supported = ReduxTemplates\Supported_Plugins::instance();
 			$supported->init( $data['plugins'] );
 			$data['plugins']                               = $supported::get_plugins();
 			$data['plugins']['redux-framework']['version'] = \Redux_Core::$version;
 			if ( \Redux_Helpers::mokama() ) {
 				if ( class_exists( 'Redux_Pro' ) ) {
 					$data['plugins']['redux-framework']['is_pro'] = \Redux_Pro::$version;
 				} else {
 					$data['plugins']['redux-framework']['is_pro'] = \Redux_Core::$version;
 				}
 			}
 			$data = $this->process_dependencies( $data, 'sections' );
 			$data = $this->process_dependencies( $data, 'pages' );
 		}
 
 		if ( class_exists( 'WP_Patterns_Registry' ) ) {
 			$patterns = \WP_Patterns_Registry::get_instance()->get_all_registered();
 			foreach ( $patterns as $k => $p ) {
 				$id                      = 'wp_block_pattern_' . $k;
 				$data['sections'][ $id ] = array(
 					'name'       => $p['title'],
 					'categories' => array( 'WP Block Patterns' ),
 					'source'     => 'wp_block_patterns',
 					'id'         => $id,
 				);
 			}
 		}
 
 		wp_send_json_success( $data );
 	}
 
 	/**
 	 * Filter an array recursively.
 	 *
 	 * @param array $input Array to filter.
 	 *
 	 * @return array Filtered array.
 	 */
 	private function array_filter_recursive( $input ) {
 		foreach ( $input as &$value ) {
 			if ( is_array( $value ) ) {
 				$value = $this->array_filter_recursive( $value );
 			}
 		}
 
 		return array_filter( $input );
 	}
 
 	/**
 	 * Method for transmitting a template the user is sharing remotely.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 *
 	 * @since 4.0.0
 	 */
 	public function share_template( \WP_REST_Request $request ) {
 		$parameters = $request->get_params();
 		$attributes = $request->get_attributes();
 		$parameters = $this->process_registered_blocks( $parameters );
 
 		if ( empty( $parameters ) ) {
 			wp_send_json_error( 'No template data found.' );
 		}
 
 		$config = array(
 			'path'           => 'template_share/',
 			'uid'            => get_current_user_id(),
 			'editor_content' => isset( $parameters['editor_content'] ) ? (string) $parameters['editor_content'] : '',
 			'editor_blocks'  => isset( $parameters['editor_blocks'] ) ? $parameters['editor_blocks'] : '',
 			'postID'         => isset( $parameters['postID'] ) ? (string) sanitize_text_field( $parameters['postID'] ) : '',
 			'title'          => isset( $parameters['title'] ) ? (string) sanitize_text_field( $parameters['title'] ) : 'The Title',
 			'type'           => isset( $parameters['type'] ) ? (string) sanitize_text_field( $parameters['type'] ) : 'page',
 			'categories'     => isset( $parameters['categories'] ) ? (string) sanitize_text_field( $parameters['categories'] ) : '',
 			'description'    => isset( $parameters['description'] ) ? (string) sanitize_text_field( $parameters['description'] ) : '',
 			'headers'        => array(
 				'Redux-Registered-Blocks' => isset( $parameters['registered_blocks'] ) ? (string) sanitize_text_field( implode( ',', $parameters['registered_blocks'] ) ) : '',
 			),
 		);
 
 		$config = $this->array_filter_recursive( $config );
 
 		if ( ! isset( $config['title'] ) ) {
 			wp_send_json_error( array( 'messages' => 'A title is required.' ) );
 		}
 		if ( ! isset( $config['type'] ) ) {
 			wp_send_json_error( array( 'messages' => 'A type is required.' ) );
 		}
 
 		$response = $this->api_request( $config );
 
 		// phpcs:ignore WordPress.PHP.NoSilencedErrors
 		$data = @json_decode( $response, true );
 
 		if ( 'success' === $data['status'] && isset( $data['url'] ) ) {
 			wp_send_json_success( array( 'url' => $data['url'] ) );
 		}
 
 		wp_send_json_error( $data );
 
 	}
 
 	/**
 	 * Run an API request.
 	 *
 	 * @param array $data Array related to an API request.
 	 *
 	 * @return string API response string.
 	 */
 	public function api_request( $data ) {
 
 		$api_url = $this->api_base_url;
 
 		if ( isset( $data['path'] ) ) {
 			if ( 'library/' === $data['path'] ) {
 				$api_url = 'https://files.redux.io/library.json';
 				$request = wp_remote_get( $api_url, array( 'timeout' => $this->timeout ) );
 				if ( is_wp_error( $request ) ) {
 					wp_send_json_error(
 						array(
 							'success'       => 'false',
 							'message'       => $request->get_error_messages(),
 							'message_types' => 'error',
 						)
 					);
 				}
 				if ( 404 === wp_remote_retrieve_response_code( $request ) ) {
 					wp_send_json_error(
 						array(
 							'success'       => 'false',
 							'message'       => 'Error fetching library, URL not found. Please try again',
 							'message_types' => 'error',
 						)
 					);
 				}
 				return $request['body'];
 			}
 			$api_url = $api_url . $data['path'];
 		}
 
 		if ( isset( $data['_locale'] ) ) {
 			unset( $data['_locale'] );
 		}
 		$headers = array();
 		if ( isset( $data['headers'] ) ) {
 			$headers = $data['headers'];
 			unset( $data['headers'] );
 		}
 		if ( isset( $data['p'] ) ) {
 			$headers['Redux-P'] = $data['p'];
 			unset( $data['p'] );
 		}
 		if ( isset( $data['path'] ) ) {
 			$headers['Redux-Path'] = $data['path'];
 			unset( $data['path'] );
 		}
 
 		$headers['Redux-Slug'] = \Redux_Helpers::get_hash();
 
 		$headers = wp_parse_args( $headers, $this->default_request_headers );
 
 		$headers['Content-Type'] = 'application/json; charset=utf-8';
 		$headers                 = array_filter( $headers );
 
 		if ( isset( $_SERVER['HTTP_USER_AGENT'] ) && ! empty( $_SERVER['HTTP_USER_AGENT'] ) ) {
 			$headers['Redux-User-Agent'] = (string) sanitize_text_field( wp_unslash( $_SERVER['HTTP_USER_AGENT'] ) );
 		}
 
 		$headers['Redux-SiteURL'] = get_site_url( get_current_blog_id() );
 
 		$post_args = array(
 			'timeout'     => $this->timeout,
 			'body'        => wp_json_encode( $data ),
 			'method'      => 'POST',
 			'data_format' => 'body',
 			'redirection' => 5,
 			'headers'     => $headers,
 		);
 
 		$request = wp_remote_post( $api_url, $post_args );
 
 		// Handle redirects.
 		if ( ! is_wp_error( $request ) && isset( $request['http_response'] ) && $request['http_response'] instanceof \WP_HTTP_Requests_Response && method_exists( $request['http_response'], 'get_response_object' ) && strpos( $request['http_response']->get_response_object()->url, 'files.redux.io' ) !== false ) {
 			if ( isset( $data['no_redirect'] ) ) {
 				return $request['http_response']->get_response_object()->url;
 			} else {
 				$request = wp_remote_get( $request['http_response']->get_response_object()->url, array( 'timeout' => $this->timeout ) );
 			}
 		}
 
 		if ( is_wp_error( $request ) ) {
 
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => $request->get_error_messages(),
 					'message_types' => 'error',
 				)
 			);
 		}
 
 		if ( 404 === wp_remote_retrieve_response_code( $request ) ) {
 			return false;
 		}
 
 		return $request['body'];
 	}
 
 	/**
 	 * Fetch a single template.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 *
 	 * @since 4.0.0
 	 */
 	public function get_template( \WP_REST_Request $request ) {
 
 		$parameters = $request->get_params();
 		$attributes = $request->get_attributes();
 		$parameters = $this->process_registered_blocks( $parameters );
 
 		if ( in_array( $parameters['type'], array( 'sections', 'pages' ), true ) ) {
 			$parameters['type'] = substr_replace( $parameters['type'], '', - 1 );
 		}
 
 		$config = array(
 			'path'   => 'template/',
 			'id'     => sanitize_text_field( $parameters['id'] ),
 			'type'   => (string) sanitize_text_field( $parameters['type'] ),
 			'source' => isset( $parameters['source'] ) ? $parameters['source'] : '',
 		);
 
 		$template_response = $this->check_template_response( $parameters );
 
 		if ( 'wp_block_patterns' === $config['source'] && class_exists( 'WP_Patterns_Registry' ) ) {
 			$patterns = \WP_Patterns_Registry::get_instance()->get_all_registered();
 			$id       = explode( '_', $config['id'] );
 			$id       = end( $id );
 
 			if ( isset( $patterns[ $id ] ) ) {
 				$response = array( 'template' => $patterns[ $id ]['content'] );
 			}
 		} else {
 			$cache_path             = $config['type'] . DIRECTORY_SEPARATOR . $config['id'] . '.json';
 			$parameters['no_cache'] = 1;
 			$response               = $this->api_cache_fetch( $parameters, $config, $cache_path );
 			if ( false === $response ) {
 				wp_send_json_error(
 					array(
 						'success'       => 'false',
 						'message'       => 'Error fetching template. Please try again',
 						'message_types' => 'error',
 					)
 				);
 			}
 			$response = wp_parse_args( $response, $template_response );
 		}
 
 		if ( ! empty( $response ) && isset( $response['message'] ) ) {
 			$response['template'] = $response['message'];
 			unset( $response['message'] );
 		}
 
 		wp_send_json_success( $response );
 	}
 
 	/**
 	 * Check template reponse.
 	 *
 	 * @param array $parameters Parameters array.
 	 *
 	 * @return array
 	 * @since 4.0.0
 	 */
 	public function check_template_response( $parameters ) {
 		$response = array();
 		if ( ! \Redux_Helpers::mokama() ) {
 			if ( \Redux_Functions_Ex::activated() ) {
 				$response['left'] = 999;
 			} else {
 				$count = ReduxTemplates\Init::left( $parameters['uid'] );
 
 				$count = intval( $count ) - 1;
 				if ( 0 === $count ) {
 					$response['left'] = $count;
 					update_user_meta( $parameters['uid'], '_redux_templates_counts', -1 );
 				} elseif ( $count < 0 ) {
 					wp_send_json_error(
 						array(
 							'message' => 'Please activate Redux',
 							'left'    => 0,
 						)
 					);
 				} else {
 					update_user_meta( $parameters['uid'], '_redux_templates_counts', $count );
 				}
 				$response['left'] = $count;
 			}
 		}
 
 		return $response;
 	}
 
 	/**
 	 * Check template reponse.
 	 *
 	 * @param array $parameters Parameters array.
 	 *
 	 * @since 4.0.0
 	 */
 	public function activate_redux( $parameters ) {
 		if ( \Redux_Functions_Ex::activated() ) {
 			$response['left'] = 999;
 		} else {
 			\Redux_Core::$insights->optin();
 			if ( \Redux_Functions_Ex::activated() ) {
 				$response['left'] = 999;
 			} else {
 				$count = get_user_meta( get_current_user_id(), '_redux_templates_counts', true );
 				if ( false === $count ) {
 					$count = Init::$default_left;
 					update_user_meta( get_current_user_id(), '_redux_templates_counts', $count );
 				}
 				$response = array(
 					'left' => $count,
 				);
 			}
 		}
 		if ( 999 === $response['left'] ) {
 			wp_send_json_success( $response );
 		}
 		wp_send_json_error( $response );
 	}
 
 	/**
 	 * Fetch a single template.
 	 *
 	 * @param array $data Data array.
 	 *
 	 * @return array
 	 * @since 4.0.0
 	 */
 	public function request_verify( $data = array() ) {
 		$config = array(
 			'Redux-Version'   => REDUXTEMPLATES_VERSION,
 			'Redux-Multisite' => is_multisite(),
 			'Redux-Mokama'    => \Redux_Helpers::mokama(),
 			'Redux-Insights'  => \Redux_Core::$insights->tracking_allowed(),
 		);
 
 		// TODO - Update this with the EDD key or developer key.
 		$config['Redux-API-Key'] = '';
 
 		if ( ! empty( \Redux_Core::$pro_loaded ) && \Redux_Core::$pro_loaded ) {
 			$config['Redux-Pro'] = \Redux_Core::$pro_loaded;
 		}
 		$data = wp_parse_args( $data, $config );
 
 		return $data;
 	}
 
 
 	/**
 	 * Get all saved blocks (reusable blocks).
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 *
 	 * @since 4.0.0
 	 */
 	public function get_saved_blocks( \WP_REST_Request $request ) {
 		$args      = array(
 			'post_type'   => 'wp_block',
 			'post_status' => 'publish',
 		);
 		$r         = wp_parse_args( null, $args );
 		$get_posts = new \WP_Query();
 		$wp_blocks = $get_posts->query( $r );
 		wp_send_json_success( $wp_blocks );
 	}
 
 	/**
 	 * Delete a single saved (reusable) block
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 *
 	 * @since 4.0.0
 	 */
 	public function delete_saved_block( \WP_REST_Request $request ) {
 		$parameters = $request->get_params();
 		$attributes = $request->get_attributes();
 		if ( ! isset( $parameters['block_id'] ) ) {
 			return wp_send_json_error(
 				array(
 					'status'  => 'error',
 					'message' => 'Missing block_id.',
 				)
 			);
 		}
 
 		$block_id      = (int) sanitize_text_field( wp_unslash( $parameters['block_id'] ) );
 		$deleted_block = wp_delete_post( $block_id );
 
 		wp_send_json_success( $deleted_block );
 	}
 
 	/**
 	 * Record that the user has used the welcome guide.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 *
 	 * @since 4.0.0
 	 */
 	public function welcome_guide( \WP_REST_Request $request ) {
 		$parameters = $request->get_params();
 		$attributes = $request->get_attributes();
 		if ( ! isset( $parameters['uid'] ) ) {
 			return wp_send_json_error(
 				array(
 					'status'  => 'error',
 					'message' => 'User ID required.',
 				)
 			);
 		}
 		update_user_meta( $parameters['uid'], '_redux_welcome_guide', '1' );
 		wp_send_json_success( array( 'status' => 'success' ) );
 	}
 
 	/**
 	 * Method used to register all rest endpoint hooks.
 	 *
 	 * @since 4.0.0
 	 */
 	public function register_api_hooks() {
 
 		$hooks = array(
 			'library'            => array(
 				'callback' => 'get_index',
 			),
 			'pages'              => array(
 				'callback' => 'get_index',
 			),
 			'sections'           => array(
 				'callback' => 'get_index',
 			),
 			'collections'        => array(
 				'callback' => 'get_index',
 			),
 			'feedback'           => array(
 				'callback' => 'send_feedback',
 			),
 			'suggestion'         => array(
 				'callback' => 'send_suggestion',
 			),
 			'template'           => array(
 				'callback' => 'get_template',
 			),
 			'share'              => array(
 				'method'   => 'POST',
 				'callback' => 'share_template',
 			),
 			'get_saved_blocks'   => array(
 				'callback' => 'get_saved_blocks',
 			),
 			'delete_saved_block' => array(
 				'method'   => 'POST',
 				'callback' => 'delete_saved_block',
 			),
 			'activate'           => array(
 				'method'   => 'GET',
 				'callback' => 'activate_redux',
 			),
 			'plugin-install'     => array(
 				'method'   => 'GET',
 				'callback' => 'plugin_install',
 			),
 			'license'            => array(
 				'method'   => 'GET',
 				'callback' => 'license',
 			),
 			'license-validate'   => array(
 				'method'   => 'GET',
 				'callback' => 'validate_license',
 			),
 			'license-activate'   => array(
 				'method'   => 'GET',
 				'callback' => 'activate_license',
 			),
 			'license-deactivate' => array(
 				'method'   => 'GET',
 				'callback' => 'deactivate_license',
 			),
 			'get-pro-url'        => array(
 				'method'   => 'GET',
 				'callback' => 'get_pro_url',
 			),
 			'opt_out'            => array(
 				'method'   => 'GET',
 				'callback' => 'opt_out_account',
 			),
 			'welcome'            => array(
 				'method'   => 'POST',
 				'callback' => 'welcome_guide',
 			),
 			'nps'                => array(
 				'method'   => 'POST',
 				'callback' => 'send_nps',
 			),
 		);
 		$fs    = \Redux_Filesystem::get_instance();
 
 		foreach ( $hooks as $route => $data ) {
 			$methods = array( 'GET', 'POST' );
 			if ( isset( $data['method'] ) ) {
 				$methods = explode( ',', $data['method'] );
 			}
 
 			foreach ( $methods as $method ) {
 				$args = array(
 					'methods'  => $method,
 					'callback' => array( $this, $data['callback'] ),
 					'args'     => array(),
 				);
 				if ( defined( 'REDUX_PLUGIN_FILE' ) && ! $fs->file_exists( trailingslashit( dirname( REDUX_PLUGIN_FILE ) ) . 'local_developer.txt' ) ) {
 					$args['permission_callback'] = function () {
 						return current_user_can( 'install_plugins' );
 					};
 				} else {
 					$args['permission_callback'] = '__return_true';
 				}
 
 				register_rest_route(
 					'redux/v1/templates',
 					$route,
 					$args
 				);
 			}
 		}
 
 	}
 
 	/**
 	 * Install plugin endpoint.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 *
 	 * @since 4.0.0
 	 */
 	public function plugin_install( \WP_REST_Request $request ) {
 
 		$data = $request->get_params();
 
 		if ( empty( $data['slug'] ) ) {
 			wp_send_json_error(
 				array(
 					'error' => __( 'Slug not specified.', 'redux-framework' ),
 				)
 			);
 		}
 
 		$slug = (string) sanitize_text_field( $data['slug'] );
 		if ( ! empty( $data['redux_pro'] ) ) {
 			if ( \Redux_Helpers::mokama() || 'redux-pro' === $slug ) {
 				$config                 = array(
 					'path'        => 'installer/',
 					'slug'        => $slug,
 					'no_redirect' => true,
 				);
 				$parameters['no_cache'] = 1;
 
 				if ( 'redux-pro' === $slug ) {
 
 					$lic_status = get_option( 'redux_pro_license_status', false );
 
 					if ( 'valid' !== $lic_status && 'active' !== $lic_status ) {
 						$status = array(
 							'error' => __( 'Redux Pro license not active, please activate.', 'redux-framework' ),
 						);
 					} else {
 						$array   = array(
 							'edd_action' => 'get_version',
 						);
 						$request = $this->do_license_request( $array );
 
 						if ( isset( $request['download_link'] ) ) {
 							$status = ReduxTemplates\Installer::run( $slug, $request['download_link'] );
 						} else {
 							$status = array(
 								'error' => __( 'Invalid license key.', 'redux-framework' ),
 							);
 							delete_option( 'redux_pro_license_status' );
 						}
 					}
 				} else {
 					$response = $this->api_cache_fetch( $parameters, $config, false, false );
 					if ( isset( $response['message'] ) && false !== strpos( $response['message'], 'redux.io' ) ) {
 						$status = ReduxTemplates\Installer::run( $slug, $response['message'] );
 					} else {
 						if ( isset( $response['error'] ) && ! empty( $response['error'] ) ) {
 							$status = array(
 								'error' => $response['error'],
 							);
 						} else {
 							$status = array(
 								'error' => __( 'A valid Redux Pro subscription is required.', 'redux-framework' ),
 							);
 						}
 					}
 				}
 			} else {
 				$status = array(
 					'error' => __( 'A valid Redux Pro subscription is required.', 'redux-framework' ),
 				);
 			}
 		} else {
 			$status = ReduxTemplates\Installer::run( $slug );
 		}
 
 		if ( isset( $status['error'] ) ) {
 			wp_send_json_error( $status );
 		}
 		if ( 'otter-blocks' === $slug ) {
 			update_option( 'themeisle_blocks_settings_default_block', false );
 		}
 		wp_send_json_success( $status );
 	}
 
 	/**
 	 * Check the license key.
 	 *
 	 * @since 4.1.18
 	 * @return bool|array
 	 */
 	protected function check_license_key() {
 		$lic = get_option( 'redux_pro_license_key' );
 		if ( empty( $lic ) ) {
 			delete_option( 'redux_pro_license_status' );
 			return array(
 				'success'       => 'false',
 				'message'       => 'No license found.',
 				'message_types' => 'error',
 			);
 		}
 		return true;
 	}
 
 	/**
 	 * Run the license API calls.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 * @since 4.1.18
 	 */
 	public function license( \WP_REST_Request $request ) {
 		$data = $request->get_params();
 
 		if ( ! isset( $data['key'] ) || ( isset( $data['key'] ) && empty( $data['key'] ) ) ) {
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => 'License key not provided or empty.',
 					'message_types' => 'error',
 				)
 			);
 		}
 
 		$array    = array(
 			'edd_action' => 'check_license',
 			'license'    => $data['key'],
 		);
 		$response = $this->do_license_request( $array );
 
 		if ( isset( $response['license'] ) && in_array( $response['license'], array( 'valid', 'site_inactive', 'inactive' ), true ) ) {
 			if ( 'valid' === $response['license'] ) {
 				wp_send_json_success( array( 'status' => 'success' ) );
 			} else {
 				if ( 0 === $response['data']['activations_left'] ) {
 					delete_option( 'redux_pro_license_key' );
 					wp_send_json_error(
 						array(
 							'status'  => 'error',
 							'message' => __( 'You have reached your activation limits for Redux Pro', 'redux-framework' ),
 						)
 					);
 				}
 				update_option( 'redux_pro_license_key', $data['key'] );
 
 				$array = array(
 					'edd_action' => 'activate_license',
 				);
 
 				$response = $this->do_license_request( $array );
 				if ( isset( $response['license'] ) && 'valid' === $response['license'] ) {
 					\Redux_Functions_Ex::set_activated();
 					wp_send_json_success( $response );
 				}
 			}
 		}
 		wp_send_json_error(
 			array(
 				'status'   => 'error',
 				'msg'      => __( 'Invalid license key.', 'redux-framework' ),
 				'response' => $response,
 			)
 		);
 	}
 
 	/**
 	 * Validate a license key.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 * @since 4.1.18
 	 */
 	public function validate_license( \WP_REST_Request $request ) {
 
 		$data = $request->get_params();
 
 		if ( ! isset( $data['key'] ) || ( isset( $data['key'] ) && empty( $data['key'] ) ) ) {
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => 'License key not provided or empty.',
 					'message_types' => 'error',
 				)
 			);
 		}
 
 		$array    = array(
 			'edd_action' => 'check_license',
 			'license'    => $data['key'],
 		);
 		$response = $this->do_license_request( $array );
 
 		if ( isset( $response['license'] ) && in_array( $response['key'], array( 'valid', 'site_inactive' ), true ) ) {
 			update_option( 'redux_pro_license_status', $data['key'] );
 			wp_send_json_success( $response );
 		} else {
 			wp_send_json_error(
 				$response
 			);
 		}
 	}
 
 	/**
 	 * Activate a license key.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 * @since 4.1.18
 	 */
 	public function activate_license( \WP_REST_Request $request ) {
 		$check = $this->check_license_key();
 		if ( is_array( $check ) ) {
 			wp_send_json_error( $check );
 		}
 		$lic = get_option( 'redux_pro_license_key' );
 		if ( empty( $lic ) ) {
 			delete_option( 'redux_pro_license_status' );
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => 'No license found.',
 					'message_types' => 'error',
 				)
 			);
 		}
 
 		$array   = array(
 			'edd_action' => 'activate_license',
 		);
 		$request = $this->do_license_request( $array );
 
 		if ( isset( $request['license'] ) && 'valid' === $request['license'] ) {
 			wp_send_json_success( $request );
 		}
 		wp_send_json_error(
 			array(
 				'success'       => 'false',
 				'message'       => 'License is not valid.',
 				'message_types' => 'error',
 			)
 		);
 	}
 
 	/**
 	 * Deactivate a license key.
 	 *
 	 * @since 4.1.18
 	 */
 	public function deactivate_license() {
 		$check = $this->check_license_key();
 		if ( is_array( $check ) ) {
 			wp_send_json_error( $check );
 		}
 		$lic = get_option( 'redux_pro_license_key' );
 		if ( empty( $lic ) ) {
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => 'No license found.',
 					'message_types' => 'error',
 				)
 			);
 		}
 
 		$array   = array(
 			'edd_action' => 'deactivate_license',
 		);
 		$request = $this->do_license_request( $array );
 		if ( isset( $request['license'] ) && 'deactivated' === $request['license'] ) {
 			delete_option( 'redux_pro_license_key' );
 			wp_send_json_success( $request );
 		}
 		wp_send_json_error(
 			array(
 				'success'       => 'false',
 				'message'       => 'License is not valid.',
 				'message_types' => 'error',
 			)
 		);
 	}
 
 	/**
 	 * Get the Redux Pro download URL.
 	 *
 	 * @since 4.1.18
 	 */
 	public function get_pro_url() {
 		$lic_status = get_option( 'redux_pro_license_status', 'inactive' );
 
 		if ( 'valid' !== $lic_status && 'active' !== $lic_status ) {
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => 'License not active, please activate.',
 					'message_types' => 'error',
 				)
 			);
 		}
 
 		$array   = array(
 			'edd_action' => 'get_version',
 		);
 		$request = $this->do_license_request( $array );
 
 		if ( isset( $request['download_link'] ) ) {
 			wp_send_json_success( $request['download_link'] );
 		}
 
 		wp_send_json_error(
 			array(
 				'success'       => 'false',
 				'message'       => 'Could not recover Pro download URL.',
 				'message_types' => 'error',
 			)
 		);
 	}
 
 	/**
 	 * Run the license API calls.
 	 *
 	 * @param array $args Array of args.
 	 * @since 4.1.18
 	 * @return mixed
 	 */
 	private function do_license_request( $args ) {
 
 		$defaults = array(
 			'item_name' => 'Redux Pro',
 			'url'       => network_site_url(),
 			'license'   => get_option( 'redux_pro_license_key' ),
 		);
 		$args     = wp_parse_args( $args, $defaults );
 
 		if ( ! isset( $args['edd_action'] ) || ( isset( $args['edd_action'] ) && empty( $args['edd_action'] ) ) ) {
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => 'Missing edd_action.',
 					'message_types' => 'error',
 				)
 			);
 		}
 
 		if ( 'check_license' !== $args['edd_action'] ) {
 			$check = $this->check_license_key();
 			if ( is_array( $check ) ) {
 				wp_send_json_error( $check );
 			}
 		}
 
 		$url = add_query_arg( $args, $this->license_base_url );
 
 		$request = wp_remote_get( $url, array( 'timeout' => $this->timeout ) );
 		if ( is_wp_error( $request ) ) {
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => $request->get_error_messages(),
 					'message_types' => 'error',
 				)
 			);
 		}
 		if ( 404 === wp_remote_retrieve_response_code( $request ) ) {
 			wp_send_json_error(
 				array(
 					'success'       => 'false',
 					'message'       => 'Our API appears to be down... please try again later.',
 					'message_types' => 'error',
 				)
 			);
 		}
 		$data = json_decode( $request['body'], true );
 		if ( isset( $data['license'] ) ) {
 			update_option( 'redux_pro_license_status', $data['license'] );
 		}
 		return $data;
 	}
 
 	/**
 	 * Send the NPS value.
 	 *
 	 * @param \WP_REST_Request $request WP Rest request.
 	 * @since 4.1.19
 	 */
 	public function send_nps( \WP_REST_Request $request ) {
 		$data = $request->get_params();
 
 		if ( empty( $data['nps'] ) ) {
 			wp_send_json_error(
 				array(
 					'error' => __( 'NPS not specified.', 'redux-framework' ),
 				)
 			);
 		}
 
 		$nps         = (string) sanitize_text_field( $data['nps'] );
 		$the_request = array(
 			'path' => 'nps',
 			'nps'  => $nps,
 		);
 		$response    = $this->api_request( $the_request );
 		if ( false === $response ) {
 			wp_send_json_error(
 				array(
 					'message' => __( 'Could not record score.', 'redux-framework' ),
 				)
 			);
 		}
 		wp_send_json_success( json_decode( $response ) );
 	}
 
 }