Source: classes/controller/rest.php

  1. <?php
  3. namespace wpbuddy\rich_snippets;
  5. if ( ! defined( 'ABSPATH' ) ) {
  6. 	exit;
  7. } // Exit if accessed directly
  10. /**
  11.  * Class Rest.
  12.  *
  13.  * Here for any REST things.
  14.  *
  15.  * @package wpbuddy\rich_snippets
  16.  *
  17.  * @since   2.0.0
  18.  */
  19. class Rest_Controller {
  21. 	const RETURN_TYPES_ALLOWED = array( 'exact', 'all', 'required', 'parents' );
  24. 	/**
  25. 	 * The instance.
  26. 	 *
  27. 	 * @var \wpbuddy\rich_snippets\Rest_Controller
  28. 	 *
  29. 	 * @since 2.0.0
  30. 	 */
  31. 	protected static $_instance = null;
  34. 	/**
  35. 	 * Get the singleton instance.
  36. 	 *
  37. 	 * Creates a new instance of the class if it does not exists.
  38. 	 *
  39. 	 * @return \wpbuddy\rich_snippets\Rest_Controller
  40. 	 *
  41. 	 * @since 2.0.0
  42. 	 */
  43. 	public static function instance() {
  45. 		if ( null === self::$_instance ) {
  46. 			self::$_instance = new self;
  47. 		}
  49. 		return self::$_instance;
  50. 	}
  53. 	/**
  54. 	 * Magic function for cloning.
  55. 	 *
  56. 	 * Disallow cloning as this is a singleton class.
  57. 	 *
  58. 	 * @since 2.0.0
  59. 	 */
  60. 	protected function __clone() {
  61. 	}
  64. 	/**
  65. 	 * Magic method for setting upt the class.
  66. 	 *
  67. 	 * Disallow external instances.
  68. 	 *
  69. 	 * @since 2.0.0
  70. 	 */
  71. 	protected function __construct() {
  72. 	}
  75. 	/**
  76. 	 * Initializes admin stuff
  77. 	 *
  78. 	 * @since 2.0.0
  79. 	 */
  80. 	public static function init() {
  82. 		$instance = self::instance();
  84. 		# register routes
  85. 		$instance->register_routes();
  87. 		# load translations
  88. 		Admin_Controller::instance()->load_translations();
  89. 	}
  92. 	/**
  93. 	 * Registers the REST routes.
  94. 	 *
  95. 	 * @since 2.0.0
  96. 	 */
  97. 	protected function register_routes() {
  99. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'positions/value-select', array(
  100. 			'methods'             => \WP_REST_Server::READABLE,
  101. 			'callback'            => array( self::instance(), 'load_position_value_select' ),
  102. 			'permission_callback' => function ( $request ) {
  104. 				return apply_filters(
  105. 					'wpbuddy/rich_snippets/rest/permission',
  106. 					current_user_can( 'manage_options' ),
  107. 					$request
  108. 				);
  109. 			},
  110. 			'args'                => array(
  111. 				'param' => array(
  112. 					'validate_callback' => function ( $param, $request, $key ) {
  114. 						$param_groups = Admin_Position_Controller::instance()->get_params();
  116. 						foreach ( $param_groups as $param_list ) {
  117. 							if ( isset( $param_list['params'][ $param ] ) ) {
  118. 								return true;
  119. 							}
  120. 						}
  122. 						return false;
  124. 					},
  125. 					'sanitize_callback' => function ( $param ) {
  127. 						return sanitize_text_field( $param );
  128. 					},
  129. 				),
  130. 			),
  131. 		) );
  133. 		register_rest_route( 'wpbuddy/rich_snippets/v2', 'positions/value-select', array(
  134. 			'methods'             => \WP_REST_Server::READABLE,
  135. 			'callback'            => array( self::instance(), 'load_position_value_select_options' ),
  136. 			'permission_callback' => function ( $request ) {
  138. 				return apply_filters(
  139. 					'wpbuddy/rich_snippets/rest/permission',
  140. 					current_user_can( 'manage_options' ),
  141. 					$request
  142. 				);
  143. 			},
  144. 			'args'                => array(
  145. 				'param' => array(
  146. 					'validate_callback' => function ( $param, $request, $key ) {
  148. 						$param_groups = Admin_Position_Controller::instance()->get_params();
  150. 						foreach ( $param_groups as $param_list ) {
  151. 							if ( isset( $param_list['params'][ $param ] ) ) {
  152. 								return true;
  153. 							}
  154. 						}
  156. 						return false;
  158. 					},
  159. 					'sanitize_callback' => function ( $param ) {
  161. 						return sanitize_text_field( $param );
  162. 					},
  163. 				),
  164. 			),
  165. 		) );
  167. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'positions/value-possibilities', array(
  168. 			'methods'             => \WP_REST_Server::READABLE,
  169. 			'callback'            => array( self::instance(), 'load_position_value_possibilities' ),
  170. 			'permission_callback' => function ( $request ) {
  172. 				return apply_filters(
  173. 					'wpbuddy/rich_snippets/rest/permission',
  174. 					current_user_can( 'manage_options' ),
  175. 					$request
  176. 				);
  177. 			},
  178. 			'args'                => array(
  179. 				'q'     => array(
  180. 					'required'          => true,
  181. 					'sanitize_callback' => function ( $param ) {
  183. 						return sanitize_text_field( $param );
  184. 					},
  185. 				),
  186. 				'page'  => array(
  187. 					'sanitize_callback' => function ( $param ) {
  189. 						return absint( $param );
  190. 					},
  191. 				),
  192. 				'param' => array(
  193. 					'validate_callback' => function ( $param, $request, $key ) {
  195. 						$param_groups = Admin_Position_Controller::instance()->get_params();
  197. 						foreach ( $param_groups as $param_list ) {
  198. 							if ( isset( $param_list['params'][ $param ] ) ) {
  199. 								return true;
  200. 							}
  201. 						}
  203. 						return false;
  205. 					},
  206. 					'sanitize_callback' => function ( $param ) {
  208. 						return sanitize_text_field( $param );
  209. 					},
  210. 				),
  211. 			),
  212. 		) );
  215. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/admin/verify', array(
  216. 			'methods'             => \WP_REST_Server::READABLE,
  217. 			'callback'            => array( self::instance(), 'activate_plugin' ),
  218. 			'permission_callback' => function ( $request ) {
  220. 				/**
  221. 				 * REST Permission filter.
  222. 				 *
  223. 				 * Allows to modify the capability for the REST access.
  224. 				 *
  225. 				 * @hook  wpbuddy/rich_snippets/rest/permission
  226. 				 *
  227. 				 * @param {string} $capability The capability for the REST access. Default: manage_options.
  228. 				 * @param {WP_Rest_Request} $request
  229. 				 *
  230. 				 * @returns {string} The capability for the REST persmission.
  231. 				 *
  232. 				 * @since 2.0.0
  233. 				 */
  234. 				return apply_filters(
  235. 					'wpbuddy/rich_snippets/rest/permission',
  236. 					current_user_can( 'manage_options' ),
  237. 					$request
  238. 				);
  239. 			},
  240. 			'args'                => array(
  241. 				'purchase_code' => array(
  242. 					'required'          => false,
  243. 					'sanitize_callback' => function ( $param ) {
  245. 						return sanitize_text_field( $param );
  246. 					},
  247. 				),
  248. 			),
  249. 		) );
  251. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schemas/types', array(
  252. 			'methods'             => \WP_REST_Server::READABLE,
  253. 			'callback'            => array( self::instance(), 'get_schema_types' ),
  254. 			'permission_callback' => function ( $request ) {
  256. 				return apply_filters(
  257. 					'wpbuddy/rich_snippets/rest/permission',
  258. 					current_user_can( 'manage_options' ),
  259. 					$request
  260. 				);
  261. 			},
  262. 			'args'                => array(
  263. 				'q'    => array(
  264. 					'required'          => true,
  265. 					'sanitize_callback' => function ( $param ) {
  267. 						return sanitize_text_field( $param );
  268. 					},
  269. 				),
  270. 				'page' => array(
  271. 					'sanitize_callback' => function ( $param ) {
  273. 						return absint( $param );
  274. 					},
  275. 				),
  276. 			),
  277. 		) );
  279. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schema', array(
  280. 			'methods'             => \WP_REST_Server::READABLE,
  281. 			'callback'            => array( self::instance(), 'get_schema_type' ),
  282. 			'permission_callback' => function ( $request ) {
  284. 				return apply_filters(
  285. 					'wpbuddy/rich_snippets/rest/permission',
  286. 					current_user_can( 'manage_options' ),
  287. 					$request
  288. 				);
  289. 			},
  290. 			'args'                => array(
  291. 				'type' => array(
  292. 					'required'          => true,
  293. 					'sanitize_callback' => function ( $param ) {
  295. 						return sanitize_text_field( $param );
  296. 					},
  297. 				),
  298. 			),
  299. 		) );
  301. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schema/examples', array(
  302. 			'methods'             => \WP_REST_Server::READABLE,
  303. 			'callback'            => array( self::instance(), 'get_schema_type_examples' ),
  304. 			'permission_callback' => function ( $request ) {
  306. 				return apply_filters(
  307. 					'wpbuddy/rich_snippets/rest/permission',
  308. 					current_user_can( 'manage_options' ),
  309. 					$request
  310. 				);
  311. 			},
  312. 			'args'                => array(
  313. 				'type' => array(
  314. 					'required'          => false,
  315. 					'sanitize_callback' => function ( $param ) {
  317. 						$v = sanitize_text_field( $param );
  318. 						if ( 1 !== preg_match( "#http(s)?:\/\/#", $v ) ) {
  319. 							$v = 'http://' . $v;
  320. 						}
  322. 						return $v;
  323. 					},
  324. 				),
  325. 				'ids'  => array(
  326. 					'required' => false,
  327. 					'type'     => 'array',
  328. 					'items'    => [
  329. 						'type' => 'integer'
  330. 					]
  331. 				),
  332. 			),
  333. 		) );
  335. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schemas/recommended', array(
  336. 			'methods'             => \WP_REST_Server::READABLE,
  337. 			'callback'            => array( self::instance(), 'get_recommended_schemas' ),
  338. 			'permission_callback' => function ( $request ) {
  340. 				return apply_filters(
  341. 					'wpbuddy/rich_snippets/rest/permission',
  342. 					current_user_can( 'manage_options' ),
  343. 					$request
  344. 				);
  345. 			},
  346. 		) );
  348. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schemas/properties', array(
  349. 			'methods'             => \WP_REST_Server::READABLE,
  350. 			'callback'            => array( self::instance(), 'get_properties' ),
  351. 			'permission_callback' => function ( $request ) {
  353. 				return apply_filters(
  354. 					'wpbuddy/rich_snippets/rest/permission',
  355. 					current_user_can( 'manage_options' ),
  356. 					$request
  357. 				);
  358. 			},
  359. 			'args'                => array(
  360. 				'schema_type' => array(
  361. 					'required'          => true,
  362. 					'sanitize_callback' => function ( $param ) {
  364. 						$v = sanitize_text_field( $param );
  365. 						if ( 1 !== preg_match( "#http(s)?:\/\/#", $v ) ) {
  366. 							$v = 'http://' . $v;
  367. 						}
  369. 						return $v;
  370. 					},
  371. 				),
  372. 				'return_type' => array(
  373. 					'required'          => true,
  374. 					'validate_callback' => function ( $param, $request, $key ) {
  376. 						return in_array( strtolower( $param ), self::RETURN_TYPES_ALLOWED );
  379. 					},
  380. 					'sanitize_callback' => function ( $param ) {
  382. 						return sanitize_text_field( strtolower( $param ) );
  383. 					},
  384. 				),
  385. 				'q'           => array(
  386. 					'sanitize_callback' => function ( $param ) {
  388. 						return sanitize_text_field( $param );
  389. 					},
  390. 				),
  391. 			),
  392. 		) );
  394. 		register_rest_route( 'wpbuddy/rich_snippets/v2', '/schemas/properties', array(
  395. 			'methods'             => \WP_REST_Server::READABLE,
  396. 			'callback'            => array( self::instance(), 'get_properties_v2' ),
  397. 			'permission_callback' => function ( $request ) {
  399. 				return apply_filters(
  400. 					'wpbuddy/rich_snippets/rest/permission',
  401. 					current_user_can( 'manage_options' ),
  402. 					$request
  403. 				);
  404. 			},
  405. 			'args'                => array(
  406. 				'schema_type'   => array(
  407. 					'required'          => true,
  408. 					'sanitize_callback' => function ( $param ) {
  410. 						$v = sanitize_text_field( $param );
  411. 						if ( 1 !== preg_match( "#http(s)?:\/\/#", $v ) ) {
  412. 							$v = 'http://' . $v;
  413. 						}
  415. 						return $v;
  416. 					},
  417. 				),
  418. 				'return_type'   => array(
  419. 					'required'          => true,
  420. 					'validate_callback' => function ( $param, $request, $key ) {
  422. 						return in_array( strtolower( $param ), self::RETURN_TYPES_ALLOWED );
  425. 					},
  426. 					'sanitize_callback' => function ( $param ) {
  428. 						return sanitize_text_field( strtolower( $param ) );
  429. 					},
  430. 				),
  431. 				'q'             => array(
  432. 					'sanitize_callback' => function ( $param ) {
  434. 						return sanitize_text_field( $param );
  435. 					},
  436. 				),
  437. 				'preconfigured' => array(
  438. 					'required'          => true,
  439. 					'default'           => false,
  440. 					'sanitize_callback' => function ( $param ) {
  442. 						return Helper_Model::instance()->string_to_bool( $param );
  443. 					},
  444. 				),
  445. 			),
  446. 		) );
  448. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schemas/property', array(
  449. 			'methods'             => \WP_REST_Server::READABLE,
  450. 			'callback'            => array( self::instance(), 'get_property' ),
  451. 			'permission_callback' => function ( $request ) {
  453. 				return apply_filters(
  454. 					'wpbuddy/rich_snippets/rest/permission',
  455. 					current_user_can( 'manage_options' ),
  456. 					$request
  457. 				);
  458. 			},
  459. 			'args'                => array(
  460. 				'property' => array(
  461. 					'required'          => true,
  462. 					'sanitize_callback' => function ( $param ) {
  464. 						$v = sanitize_text_field( $param );
  465. 						if ( 1 !== preg_match( "#http(s)?:\/\/#", $v ) ) {
  466. 							$v = 'http://' . $v;
  467. 						}
  469. 						return $v;
  470. 					},
  471. 				),
  472. 			),
  473. 		) );
  475. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schemas/property/field-types', array(
  476. 			'methods'             => \WP_REST_Server::READABLE,
  477. 			'callback'            => array( self::instance(), 'get_property_field_types' ),
  478. 			'permission_callback' => function ( $request ) {
  480. 				return apply_filters(
  481. 					'wpbuddy/rich_snippets/rest/permission',
  482. 					current_user_can( 'manage_options' ),
  483. 					$request
  484. 				);
  485. 			},
  486. 			'args'                => array(
  487. 				'property' => array(
  488. 					'required'          => true,
  489. 					'sanitize_callback' => function ( $param ) {
  491. 						$v = sanitize_text_field( $param );
  492. 						if ( 1 !== preg_match( "#http(s)?:\/\/#", $v ) ) {
  493. 							$v = 'http://' . $v;
  494. 						}
  496. 						return $v;
  497. 					},
  498. 				),
  499. 			),
  500. 		) );
  502. 		register_rest_route( 'wpbuddy/rich_snippets/v1', '/schemas/properties/html', array(
  503. 			'methods'             => \WP_REST_Server::CREATABLE,
  504. 			'callback'            => array( self::instance(), 'get_properties_html' ),
  505. 			'permission_callback' => function ( $request ) {
  507. 				return apply_filters(
  508. 					'wpbuddy/rich_snippets/rest/permission',
  509. 					current_user_can( 'manage_options' ),
  510. 					$request
  511. 				);
  512. 			},
  513. 			'args'                => array(
  514. 				'properties'     => array(
  515. 					'validate_callback' => function ( $param, $request, $key ) {
  517. 						if ( ! is_array( $param ) ) {
  518. 							return new \WP_Error(
  519. 								'wpbuddy/rich_snippets/rest/param',
  520. 								_x( 'Please provide a list of properties.',
  521. 									'Thrown error on rest api when there was no list of properties found.',
  522. 									'rich-snippets-schema' )
  523. 							);
  524. 						}
  526. 						return $param;
  528. 					},
  529. 					'sanitize_callback' => function ( $param ) {
  531. 						return array_map( function ( $v ) {
  533. 							$v = sanitize_text_field( $v );
  534. 							if ( 1 !== preg_match( "#http(s)?:\/\/#", $v ) ) {
  535. 								$v = 'http://' . $v;
  536. 							}
  538. 							return $v;
  539. 						}, $param );
  540. 					},
  541. 				),
  542. 				'include_table'  => array(
  543. 					'sanitize_callback' => function ( $param ) {
  545. 						return filter_var( $param, FILTER_VALIDATE_BOOLEAN );
  546. 					},
  547. 				),
  548. 				'schema_type'    => array(
  549. 					'sanitize_callback' => function ( $param ) {
  551. 						$v = sanitize_text_field( $param );
  552. 						if ( 1 !== preg_match( "#http(s)?:\/\/#", $v ) ) {
  553. 							$v = 'http://' . $v;
  554. 						}
  556. 						return $v;
  557. 					},
  558. 				),
  559. 				'parent_type_id' => array(
  560. 					'sanitize_callback' => function ( $param ) {
  562. 						return sanitize_text_field( $param );
  563. 					},
  564. 				),
  565. 				'post_id'        => array(
  566. 					'validate_callback' => function ( $param, $request, $key ) {
  568. 						# check if post exists
  569. 						return is_string( get_post_status( absint( $param ) ) );
  571. 					},
  572. 					'sanitize_callback' => function ( $param ) {
  574. 						return absint( $param );
  575. 					},
  576. 				),
  577. 				'snippet_id'     => array(
  578. 					'sanitize_callback' => function ( $param ) {
  580. 						return sanitize_text_field( $param );
  581. 					},
  582. 				),
  583. 				'is_main_schema' => array(
  584. 					'sanitize_callback' => function ( $param ) {
  586. 						return Helper_Model::instance()->string_to_bool( $param );
  587. 					},
  588. 				),
  589. 			),
  590. 		) );
  592. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'form_new', array(
  593. 			'methods'             => \WP_REST_Server::READABLE,
  594. 			'callback'            => array( self::instance(), 'get_rich_snippets_form_new' ),
  595. 			'permission_callback' => function ( $request ) {
  597. 				return apply_filters(
  598. 					'wpbuddy/rich_snippets/rest/permission',
  599. 					current_user_can( 'manage_options' ),
  600. 					$request
  601. 				);
  602. 			},
  603. 			'args'                => array(
  604. 				'post_id' => array(
  605. 					'validate_callback' => function ( $param, $request, $key ) {
  607. 						# check if post exists
  608. 						return is_string( get_post_status( absint( $param ) ) );
  610. 					},
  611. 					'sanitize_callback' => function ( $param ) {
  613. 						return absint( $param );
  614. 					},
  615. 				),
  616. 			),
  617. 		) );
  619. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'snippets_forms', array(
  620. 			'methods'             => [ \WP_REST_Server::READABLE, \WP_REST_Server::CREATABLE ],
  621. 			'callback'            => array( self::instance(), 'get_rich_snippets_forms' ),
  622. 			'permission_callback' => function ( $request ) {
  624. 				return apply_filters(
  625. 					'wpbuddy/rich_snippets/rest/permission',
  626. 					current_user_can( 'manage_options' ),
  627. 					$request
  628. 				);
  629. 			},
  630. 			'args'                => array(
  631. 				'post_id'   => array(
  632. 					'required'          => true,
  633. 					'validate_callback' => function ( $param, $request, $key ) {
  635. 						# check if post exists
  636. 						return is_string( get_post_status( absint( $param ) ) );
  638. 					},
  639. 					'sanitize_callback' => function ( $param ) {
  641. 						return absint( $param );
  642. 					},
  643. 				),
  644. 				'form_data' => array(
  645. 					'required'          => false,
  646. 					'default'           => [],
  647. 					'type'              => 'array',
  648. 					'validate_callback' => function ( $param, $request, $key ) {
  650. 						return is_array( $param );
  652. 					},
  653. 					'sanitize_callback' => function ( $param ) {
  655. 						$data = [];
  657. 						foreach ( $param as $key => $value ) {
  659. 							if ( ! ( isset( $value['id'], $value['properties'] ) ) ) {
  660. 								continue;
  661. 							}
  663. 							$data[ $key ] = [
  664. 								'id'   => sanitize_text_field( $value['id'] ),
  665. 								'loop' => isset( $value['loop'] ) ? sanitize_text_field( $value['loop'] ) : '',
  666. 							];
  668. 							foreach ( $value['properties'] as $prop ) {
  669. 								$data[ $key ]['properties'][] = [
  670. 									'id'                   => isset( $prop['id'] ) ? sanitize_text_field( $prop['id'] ) : '',
  671. 									'overridable'          => isset( $prop['overridable'] ) && $prop['overridable'],
  672. 									'overridable_multiple' => isset( $prop['overridable_multiple'] ) && $prop['overridable_multiple'],
  673. 									'ref'                  => isset( $prop['ref'] ) ? sanitize_text_field( $prop['ref'] ) : '',
  674. 									'subfield_select'      => isset( $prop['subfield_select'] ) ? sanitize_text_field( $prop['subfield_select'] ) : '',
  675. 									'textfield'            => isset( $prop['textfield'] ) ? sanitize_text_field( $prop['textfield'] ) : '',
  676. 								];
  677. 							}
  678. 						}
  680. 						return $data;
  681. 					},
  682. 				),
  683. 			),
  684. 		) );
  686. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'snippets_delete', array(
  687. 			'methods'             => \WP_REST_Server::CREATABLE,
  688. 			'callback'            => array( self::instance(), 'delete_snippets' ),
  689. 			'permission_callback' => function ( $request ) {
  691. 				return apply_filters(
  692. 					'wpbuddy/rich_snippets/rest/permission',
  693. 					current_user_can( 'manage_options' ),
  694. 					$request
  695. 				);
  696. 			},
  697. 			'args'                => array(
  698. 				'post_id'     => array(
  699. 					'validate_callback' => function ( $param, $request, $key ) {
  701. 						# check if post exists
  702. 						return is_string( get_post_status( absint( $param ) ) );
  703. 					},
  704. 					'sanitize_callback' => function ( $param ) {
  706. 						return absint( $param );
  707. 					},
  708. 				),
  709. 				'snippet_ids' => array(
  710. 					'validate_callback' => function ( $param, $request, $key ) {
  712. 						return is_array( $param );
  713. 					},
  714. 					'sanitize_callback' => function ( $param ) {
  716. 						if ( ! is_array( $param ) ) {
  717. 							return array();
  718. 						}
  720. 						return array_map( function ( $v ) {
  722. 							if ( ! is_scalar( $v ) ) {
  723. 								return '';
  724. 							}
  726. 							return sanitize_text_field( $v );
  727. 						}, $param );
  728. 					},
  729. 				),
  730. 			),
  731. 		) );
  733. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'clear_cache', array(
  734. 			'methods'             => \WP_REST_Server::READABLE,
  735. 			'callback'            => array( self::instance(), 'clear_cache' ),
  736. 			'permission_callback' => function ( $request ) {
  738. 				return apply_filters(
  739. 					'wpbuddy/rich_snippets/rest/permission',
  740. 					current_user_can( 'manage_options' ),
  741. 					$request
  742. 				);
  743. 			},
  744. 		) );
  746. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'faq', array(
  747. 			'methods'             => \WP_REST_Server::READABLE,
  748. 			'callback'            => array( self::instance(), 'support_faq_search' ),
  749. 			'permission_callback' => function ( $request ) {
  751. 				return apply_filters(
  752. 					'wpbuddy/rich_snippets/rest/permission',
  753. 					current_user_can( 'manage_options' ),
  754. 					$request
  755. 				);
  756. 			},
  757. 			'args'                => array(
  758. 				'q' => array(
  759. 					'required'          => true,
  760. 					'validate_callback' => function ( $param, $request, $key ) {
  762. 						$str = sanitize_text_field( $param );
  764. 						return ! empty( $str );
  765. 					},
  766. 					'sanitize_callback' => function ( $param ) {
  768. 						return sanitize_text_field( $param );
  769. 					},
  770. 				),
  771. 			),
  772. 		) );
  774. 		register_rest_route( 'wpbuddy/rich_snippets/v1', 'snips/import', array(
  775. 			'methods'             => \WP_REST_Server::CREATABLE,
  776. 			'callback'            => array( self::instance(), 'snips_import' ),
  777. 			'permission_callback' => function ( $request ) {
  779. 				return apply_filters(
  780. 					'wpbuddy/rich_snippets/rest/permission',
  781. 					current_user_can( 'manage_options' ),
  782. 					$request
  783. 				);
  784. 			},
  785. 			'args'                => array(
  786. 				'snips'      => array(
  787. 					'required' => true,
  788. 					'type'     => 'array',
  789. 					'items'    => [
  790. 						'type'    => 'integer',
  791. 						'minimum' => '1',
  792. 						'require' => true,
  793. 					],
  794. 				),
  795. 				'rulesets'   => array(
  796. 					'required'          => false,
  797. 					'type'              => 'array',
  798. 					'sanitize_callback' => function ( $param ) {
  799. 						if ( ! is_array( $param ) ) {
  800. 							return new \WP_Error(
  801. 								'wpbuddy/rich_snippets/rest/snips/import',
  802. 								__( 'Rulesets is not an array.', 'rich-snippets-schema' )
  803. 							);
  804. 						}
  806. 						$p = [];
  808. 						foreach ( $param as $snip_id => $ruleset ) {
  809. 							$snip_id = (int) $snip_id;
  811. 							if ( ! array_key_exists( 'ruleGroups', $ruleset ) ) {
  812. 								continue;
  813. 							}
  815. 							$p[ $snip_id ] = new Position_Ruleset();
  817. 							foreach ( $ruleset['ruleGroups'] as $rulegroup ) {
  819. 								if ( ! array_key_exists( 'rules', $rulegroup ) ) {
  820. 									continue;
  821. 								}
  823. 								$rp = new Position_Rule_Group();
  825. 								foreach ( $rulegroup['rules'] as $rule ) {
  826. 									$r           = new Position_Rule();
  827. 									$r->operator = sanitize_text_field( $rule['operator'] );
  828. 									$r->param    = sanitize_text_field( $rule['param'] );
  829. 									$r->value    = sanitize_text_field( $rule['value'] );
  830. 									$rp->add_rule( $r );
  831. 								}
  833. 								$p[ $snip_id ]->add_rulegroup( $rp );
  835. 							}
  837. 						}
  839. 						return $p;
  840. 					},
  841. 				),
  842. 				'properties' => array(
  843. 					'required'          => false,
  844. 					'type'              => 'array',
  845. 					'sanitize_callback' => function ( $param ) {
  847. 						if ( ! is_array( $param ) ) {
  848. 							return new \WP_Error(
  849. 								'wpbuddy/rich_snippets/rest/snips/import',
  850. 								__( 'Property is not an array.', 'rich-snippets-schema' )
  851. 							);
  852. 						}
  854. 						$test = [ 'label', 'selection', 'textValue' ];
  856. 						$p = [];
  858. 						foreach ( $param as $snip_id => $properties ) {
  859. 							$snip_id       = (int) $snip_id;
  860. 							$p[ $snip_id ] = [];
  861. 							foreach ( $properties as $prop_id => $property ) {
  862. 								foreach ( $test as $t ) {
  863. 									if ( ! array_key_exists( $t, $property ) ) {
  864. 										return new \WP_Error(
  865. 											'wpbuddy/rich_snippets/rest/snips/import',
  866. 											sprintf( __( 'Property value for %s is missing.', 'rich-snippets-schema' ), $t )
  867. 										);
  868. 									}
  870. 									$p[ $snip_id ][ $prop_id ][ $t ] = sanitize_text_field( $property[ $t ] );
  871. 								}
  872. 							}
  873. 						}
  876. 						return $p;
  877. 					},
  878. 				)
  879. 			),
  880. 		) );
  881. 	}
  884. 	/**
  885. 	 * Performs a search on schema types
  886. 	 *
  887. 	 * @param \WP_REST_Request $request
  888. 	 *
  889. 	 * @return mixed|\WP_REST_Response
  890. 	 * @since 2.0.0
  891. 	 *
  892. 	 */
  893. 	public function get_schema_types( $request ) {
  895. 		$q = $request->get_param( 'q' );
  897. 		$types = Schemas_Model::get_types( $q );
  899. 		if ( is_wp_error( $types ) ) {
  900. 			return $types;
  901. 		}
  903. 		return rest_ensure_response( array( 'schema_types' => $types ) );
  904. 	}
  907. 	/**
  908. 	 * Activates the plugin.
  909. 	 *
  910. 	 * @param \WP_REST_Request $request
  911. 	 *
  912. 	 * @return mixed|\WP_REST_Response
  913. 	 * @since 2.0.0
  914. 	 */
  915. 	public function activate_plugin( $request ) {
  917. 		$purchase_code = $request->get_param( 'purchase_code' );
  919. 		update_option( 'wpb_rs/purchase_code', $purchase_code, false );
  920. 		update_option( 'wpb_rs/active', true, true );
  922. 		$verified = apply_filters( 'wpbuddy/rich_snippets/rest/activate_plugin', true, $purchase_code, $request );
  924. 		if ( is_wp_error( $verified ) ) {
  925. 			return $verified;
  926. 		}
  928. 		return rest_ensure_response( array( 'verified' => $verified ) );
  929. 	}
  932. 	/**
  933. 	 * Fetches details about a single schema type.
  934. 	 *
  935. 	 * @param \WP_REST_Request $request
  936. 	 *
  937. 	 * @return mixed|\WP_REST_Response
  938. 	 * @since 2.14.0
  939. 	 *
  940. 	 */
  941. 	public function get_schema_type( $request ) {
  943. 		$type = $request->get_param( 'type' );
  945. 		$type_details = Schemas_Model::get_type_details( $type );
  947. 		if ( is_wp_error( $type_details ) ) {
  948. 			return $type_details;
  949. 		}
  951. 		return rest_ensure_response( $type_details );
  952. 	}
  955. 	/**
  956. 	 * Performs a search on schema properties.
  957. 	 *
  958. 	 * @param \WP_REST_Request $request
  959. 	 *
  960. 	 * @return mixed|\WP_REST_Response
  961. 	 * @since 2.0.0
  962. 	 *
  963. 	 */
  964. 	public function get_properties( $request ) {
  966. 		$properties = Schemas_Model::get_properties( array(
  967. 			'schema_type' => $request->get_param( 'schema_type' ),
  968. 			'return_type' => $request->get_param( 'return_type' ),
  969. 			'q'           => $request->get_param( 'q' ),
  970. 		) );
  972. 		if ( is_wp_error( $properties ) ) {
  973. 			return $properties;
  974. 		}
  976. 		$properties = wp_list_pluck( $properties, 'id' );
  978. 		return rest_ensure_response( array( 'properties' => $properties ) );
  979. 	}
  982. 	/**
  983. 	 * Performs a search on schema properties.
  984. 	 *
  985. 	 * @param \WP_REST_Request $request
  986. 	 *
  987. 	 * @return mixed|\WP_REST_Response
  988. 	 * @since 2.14.0
  989. 	 *
  990. 	 */
  991. 	public function get_properties_v2( $request ) {
  993. 		$properties = Schemas_Model::get_properties( array(
  994. 			'schema_type'   => $request->get_param( 'schema_type' ),
  995. 			'return_type'   => $request->get_param( 'return_type' ),
  996. 			'q'             => $request->get_param( 'q' ),
  997. 			'preconfigured' => $request->get_param( 'preconfigured' )
  998. 		) );
  1000. 		if ( is_wp_error( $properties ) ) {
  1001. 			return $properties;
  1002. 		}
  1004. 		$properties = wp_list_pluck( $properties, 'suggested_value', 'id' );
  1006. 		$properties = array_map( function ( $suggested_value ) {
  1008. 			if ( false !== stripos( $suggested_value, '://schema.org/' ) ) {
  1009. 				$label = Helper_Model::instance()->remove_schema_url( $suggested_value );
  1010. 			} else {
  1011. 				$label = Fields_Model::get_label( $suggested_value );
  1012. 			}
  1014. 			return [
  1015. 				'value' => $suggested_value,
  1016. 				'label' => $label
  1017. 			];
  1018. 		}, $properties );
  1020. 		return rest_ensure_response( array( 'properties' => $properties ) );
  1021. 	}
  1023. 	/**
  1024. 	 * Gets information about a single property.
  1025. 	 *
  1026. 	 * @param \WP_REST_Request $request
  1027. 	 *
  1028. 	 * @return mixed|\WP_REST_Response
  1029. 	 * @since 2.14.0
  1030. 	 *
  1031. 	 */
  1032. 	public function get_property( $request ) {
  1034. 		$property = $request->get_param( 'property' );
  1035. 		$prop     = Schemas_Model::get_property_by_id( $property );
  1037. 		if ( ! $prop instanceof Schema_Property ) {
  1038. 			return new \WP_Error(
  1039. 				'wpbuddy/rich_snippets/rest/schema/property',
  1040. 				__( 'This schema property does not exist.', 'rich-snippets-schema' )
  1041. 			);
  1042. 		}
  1044. 		return rest_ensure_response( $prop );
  1045. 	}
  1048. 	/**
  1049. 	 * Builds a HTML form out of properties.
  1050. 	 *
  1051. 	 * @param \WP_REST_Request $request
  1052. 	 *
  1053. 	 * @return mixed|\WP_REST_Response
  1054. 	 * @since 2.0.0
  1055. 	 *
  1056. 	 */
  1057. 	public function get_properties_html( $request ) {
  1059. 		$prop_ids       = (array) $request->get_param( 'properties' );
  1060. 		$include_table  = $request->get_param( 'include_table' );
  1061. 		$schema_type    = $request->get_param( 'schema_type' );
  1062. 		$post_id        = $request->get_param( 'post_id' );
  1063. 		$snippet_id     = $request->get_param( 'snippet_id' );
  1064. 		$is_main_schema = $request->get_param( 'is_main_schema' );
  1066. 		$snippet = Snippets_Model::get_snippet( $snippet_id, (int) $post_id );
  1068. 		if ( ! $snippet instanceof Rich_Snippet ) {
  1069. 			$snippet = new Rich_Snippet( [
  1070. 				'_is_main_snippet' => $is_main_schema,
  1071. 			] );
  1072. 			if ( ! empty( $snippet_id ) ) {
  1073. 				$snippet->id = $snippet_id;
  1074. 			}
  1075. 			$snippet->type = Helper_Model::instance()->remove_schema_url( $schema_type );
  1076. 		}
  1078. 		$controller = rich_snippets() instanceof \wpbuddy\rich_snippets\pro\Admin_Snippets_Controller ? \wpbuddy\rich_snippets\pro\Admin_Snippets_Controller::instance() : Admin_Snippets_Controller::instance();
  1080. 		if ( $include_table ) {
  1081. 			$result = $controller->get_property_table( $snippet, $prop_ids,
  1082. 				get_post( $post_id ) );
  1083. 		} else {
  1084. 			$result = $controller->get_property_table_elements( $snippet, $prop_ids,
  1085. 				get_post( $post_id ) );
  1086. 		}
  1088. 		return rest_ensure_response( $result );
  1089. 	}
  1091. 	/**
  1092. 	 * Returns the HTML form to create a rich snippet.
  1093. 	 *
  1094. 	 * @param \WP_REST_Request $request
  1095. 	 *
  1096. 	 * @return mixed|\WP_REST_Response
  1097. 	 * @since 2.0.0
  1098. 	 *
  1099. 	 */
  1100. 	public function get_rich_snippets_form_new( $request ) {
  1102. 		$post_id = $request->get_param( 'post_id' );
  1104. 		return rest_ensure_response( array(
  1105. 			'form' => $this->get_rich_snippets_form( $post_id ),
  1106. 		) );
  1107. 	}
  1110. 	/**
  1111. 	 * Get the HTML code for a snippets form.
  1112. 	 *
  1113. 	 * @param int $post_id
  1114. 	 * @param string $snippet_id
  1115. 	 *
  1116. 	 * @return string
  1117. 	 * @since 2.0.0
  1118. 	 *
  1119. 	 */
  1120. 	private function get_rich_snippets_form( $post_id, $snippet_id = null ) {
  1122. 		if ( is_null( $snippet_id ) ) {
  1123. 			$snippet = new Rich_Snippet();
  1124. 		} else {
  1125. 			$snippet = Snippets_Model::get_snippet( $snippet_id, $post_id );
  1126. 			if ( ! $snippet instanceof Rich_Snippet ) {
  1127. 				$snippet = new Rich_Snippet();
  1128. 			}
  1129. 		}
  1131. 		ob_start();
  1132. 		View::admin_posts_snippet( get_post( $post_id ), $snippet );
  1134. 		return ob_get_clean();
  1135. 	}
  1138. 	/**
  1139. 	 * Returns the HTML forms from existing snippets.
  1140. 	 *
  1141. 	 * @param \WP_REST_Request $request
  1142. 	 *
  1143. 	 * @return mixed|\WP_REST_Response
  1144. 	 * @since 2.0.0
  1145. 	 *
  1146. 	 */
  1147. 	public function get_rich_snippets_forms( $request ) {
  1149. 		$post_id        = $request->get_param( 'post_id' );
  1150. 		$form_data      = $request->get_param( 'form_data' );
  1151. 		$snippet_export = $request->get_json_params();
  1153. 		$forms = array();
  1155. 		if ( count( $form_data ) > 0 ) {
  1156. 			$snippets = Snippets_Model::sanitize_and_generate_snippets( $form_data );
  1157. 			Snippets_Model::update_snippets( $post_id, $snippets );
  1158. 		} elseif ( is_array( $snippet_export ) ) {
  1159. 			$snippet  = Snippets_Model::convert_from_json( $snippet_export );
  1160. 			$snippets = [ $snippet ];
  1161. 			Snippets_Model::update_snippets( $post_id, $snippets );
  1162. 		} else {
  1163. 			$snippets = Snippets_Model::get_snippets( $post_id );
  1164. 		}
  1166. 		if ( isset( $snippets ) ) {
  1167. 			foreach ( $snippets as $snippet_id => $rich_snippet ) {
  1168. 				$forms[] = $this->get_rich_snippets_form( $post_id, $snippet_id );
  1169. 			}
  1170. 		}
  1172. 		return rest_ensure_response( array(
  1173. 			'forms' => $forms,
  1174. 		) );
  1175. 	}
  1178. 	/**
  1179. 	 * Clears internal caches.
  1180. 	 *
  1181. 	 * @param \WP_REST_Request $request
  1182. 	 *
  1183. 	 * @return mixed|\WP_REST_Response
  1184. 	 * @since 2.0.0
  1185. 	 *
  1186. 	 */
  1187. 	public function clear_cache( $request ) {
  1189. 		$deleted = Cache_Model::clear_all_caches();
  1191. 		return rest_ensure_response( array(
  1192. 			'cache_cleared' => true,
  1193. 			'cleared_items' => absint( $deleted ),
  1194. 		) );
  1195. 	}
  1198. 	/**
  1199. 	 * Deletes snippets from a post.
  1200. 	 *
  1201. 	 * @param \WP_REST_Request $request
  1202. 	 *
  1203. 	 * @return mixed|\WP_REST_Response
  1204. 	 * @since 2.0.0
  1205. 	 *
  1206. 	 */
  1207. 	public function delete_snippets( $request ) {
  1209. 		foreach ( $request->get_param( 'snippet_ids' ) as $snippet_id ) {
  1210. 			$deleted = Snippets_Model::delete_snippet(
  1211. 				$snippet_id,
  1212. 				$request->get_param( 'post_id' )
  1213. 			);
  1215. 			if ( is_wp_error( $deleted ) ) {
  1216. 				return $deleted;
  1217. 			}
  1219. 		}
  1221. 		return rest_ensure_response( array(
  1222. 			'deleted' => true,
  1223. 		) );
  1224. 	}
  1227. 	/**
  1228. 	 * Search rich-snippets.io for FAQ results.
  1229. 	 *
  1230. 	 * @param \WP_REST_Request $request
  1231. 	 *
  1232. 	 * @return mixed|\WP_REST_Response
  1233. 	 *
  1234. 	 * @since 2.3.0
  1235. 	 */
  1236. 	public function support_faq_search( $request ) {
  1238. 		$faq_posts = WPBuddy_Model::request(
  1239. 			'/wp/v2/posts/?categories=10&per_page=20&search=' . urlencode( $request->get_param( 'q' ) )
  1240. 		);
  1242. 		if ( is_wp_error( $faq_posts ) ) {
  1243. 			return $faq_posts;
  1244. 		}
  1246. 		ob_start();
  1248. 		if ( count( $faq_posts ) <= 0 ) {
  1249. 			printf( '<li>%s</li>',
  1250. 				_x( 'Sorry, nothing matched your search query.', 'No FAQ entries found.', 'rich-snippets-schema' ) );
  1251. 		} else {
  1253. 			foreach ( $faq_posts as $faq_post ) {
  1254. 				printf(
  1255. 					'<li><a href="%s" target="_blank">%s</a><p class="description">%s</p></li>',
  1256. 					esc_url( $faq_post->link ),
  1257. 					strip_tags( $faq_post->title->rendered ),
  1258. 					wp_trim_words( strip_tags( $faq_post->excerpt->rendered ) )
  1259. 				);
  1260. 			}
  1262. 		}
  1264. 		return rest_ensure_response( [ 'html' => ob_get_clean() ] );
  1265. 	}
  1268. 	/**
  1269. 	 * Returns field type options.
  1270. 	 *
  1271. 	 * @param \WP_REST_Request $request
  1272. 	 *
  1273. 	 * @return \WP_REST_Response|\WP_Error
  1274. 	 * @since 2.14.0
  1275. 	 *
  1276. 	 */
  1277. 	public function get_property_field_types( $request ) {
  1278. 		$property_id = $request->get_param( 'property' );
  1280. 		$property = Schemas_Model::get_property_by_id( $property_id );
  1282. 		if ( ! $property instanceof Schema_Property ) {
  1283. 			return new \WP_Error(
  1284. 				'wpbuddy/rich_snippets/rest/schema/property',
  1285. 				__( 'This schema property does not exist.', 'rich-snippets-schema' )
  1286. 			);
  1287. 		}
  1289. 		new Fields_Model();
  1291. 		$internal_values = call_user_func( function ( $range ) {
  1293. 			$options = [];
  1295. 			$values = Fields_Model::get_internal_values();
  1297. 			foreach ( $values as $schema => $fields ) {
  1299. 				if ( ! in_array( $schema, $range ) ) {
  1300. 					continue;
  1301. 				}
  1303. 				foreach ( $fields as $field ) {
  1304. 					$options[ $field['label'] ] = [
  1305. 						'value'       => $field['id'],
  1306. 						'label'       => $field['label'],
  1307. 						'description' => isset( $field['description'] ) ? $field['description'] : ''
  1308. 					];
  1309. 				}
  1311. 			}
  1313. 			ksort( $options, SORT_NATURAL );
  1315. 			return array_values( $options );
  1316. 		}, $property->range_includes );
  1318. 		$related_values = call_user_func( function ( $prop ) {
  1319. 			$options = [];
  1320. 			foreach ( Fields_Model::get_related_values( $prop ) as $schema ) {
  1322. 				# filter primitive types
  1323. 				if ( in_array( $schema, Schemas_Model::PRIMITIVE_TYPES, true ) ) {
  1324. 					continue;
  1325. 				}
  1327. 				$options[] = [
  1328. 					'value'       => $schema,
  1329. 					'label'       => Helper_Model::instance()->remove_schema_url( $schema ),
  1330. 					'description' => '',
  1331. 				];
  1332. 			}
  1334. 			return $options;
  1335. 		}, $property );
  1337. 		$type_descendants_values = call_user_func( function ( $range ) {
  1338. 			$options     = [];
  1339. 			$descendants = Schemas_Model::get_type_descendants( $range );
  1341. 			if ( is_wp_error( $descendants ) ) {
  1342. 				return $options;
  1343. 			}
  1345. 			foreach ( $descendants as $type ) {
  1346. 				$options[] = [
  1347. 					'value'       => 'descendant-' . $type,
  1348. 					'label'       => Helper_Model::instance()->remove_schema_url( $type ),
  1349. 					'description' => '',
  1350. 				];
  1351. 			}
  1353. 			return $options;
  1354. 		}, $property->range_includes );
  1356. 		# Filter duplicates
  1358. 		return rest_ensure_response( [
  1359. 			'internal'    => $internal_values,
  1360. 			'related'     => $related_values,
  1361. 			'descendants' => $type_descendants_values
  1362. 		] );
  1363. 	}
  1366. 	/**
  1367. 	 * Sanitizes schemas.
  1368. 	 *
  1369. 	 * @param array $data
  1370. 	 *
  1371. 	 * @return array|\WP_Error
  1372. 	 * @since 2.14.0
  1373. 	 */
  1374. 	public function sanitize_schema_field( $data ) {
  1376. 		if ( ! is_array( $data ) ) {
  1377. 			return new \WP_Error(
  1378. 				'wpbuddy/rich_snippets/rest/sanitize_field_position',
  1379. 				__( 'An array is needed.', 'rich-snippets-schema' )
  1380. 			);
  1381. 		}
  1383. 		if ( ! isset( $data['schemas'] ) ) {
  1384. 			return new \WP_Error(
  1385. 				'wpbuddy/rich_snippets/rest/sanitize_field_position',
  1386. 				__( 'An array with a key "schemas" is needed.', 'rich-snippets-schema' )
  1387. 			);
  1388. 		}
  1390. 		$new_data = [];
  1392. 		foreach ( $data['schemas'] as $schema_url => $properties ) {
  1394. 			$s = Helper_Model::instance()->sanitize_schema_props( $properties );
  1396. 			if ( count( $s[0] ) <= 0 ) {
  1397. 				continue;
  1398. 			}
  1400. 			$uid = uniqid( 'snip-' );
  1402. 			$new_data[ $uid ] = [
  1403. 				'id'         => $schema_url,
  1404. 				'properties' => $s[0]
  1405. 			];
  1407. 			if ( isset( $s[1] ) ) {
  1408. 				$new_data = array_merge( $new_data, $s[1] );
  1409. 			}
  1410. 		}
  1412. 		return $new_data;
  1413. 	}
  1416. 	/**
  1417. 	 * Returns the schemas saved to a post.
  1418. 	 *
  1419. 	 * @param array $object
  1420. 	 * @param string $field_name
  1421. 	 * @param \WP_REST_Request $request
  1422. 	 * @param string $object_type
  1423. 	 *
  1424. 	 * @return array
  1425. 	 * @since 2.14.0
  1426. 	 *
  1427. 	 */
  1428. 	public function get_schema_field( $object, $field_name, $request, $object_type ) {
  1430. 		$meta = get_post_meta( $object['id'], '_wpb_rs_' . $field_name, true );
  1432. 		return $meta;
  1433. 	}
  1436. 	/**
  1437. 	 * Updates the schema field.
  1438. 	 *
  1439. 	 * @param                  $field_value
  1440. 	 * @param \WP_Post $object
  1441. 	 * @param string $field_name
  1442. 	 * @param \WP_REST_Request $request
  1443. 	 * @param string $object_type
  1444. 	 *
  1445. 	 * @return bool|\WP_Error
  1446. 	 * @since 2.14.0
  1447. 	 */
  1448. 	public function update_schema_field( $field_value, $object, $field_name, $request, $object_type ) {
  1450. 		$snippets = Snippets_Model::sanitize_and_generate_snippets( $field_value );
  1452. 		$updated = Snippets_Model::update_snippets( $object->ID, $snippets );
  1454. 		if ( false === $updated ) {
  1455. 			return new \WP_Error(
  1456. 				'wpbuddy/rich_snippets/rest/get_field',
  1457. 				__( 'An error occurred during the update.', 'rich-snippets-schema' ),
  1458. 				[
  1459. 					'value' => $field_value,
  1460. 				]
  1461. 			);
  1462. 		}
  1464. 		return true;
  1465. 	}
  1468. 	/**
  1469. 	 * Sanitizes data before its processed.
  1470. 	 *
  1471. 	 * @param array $data
  1472. 	 *
  1473. 	 * @return array|\WP_Error
  1474. 	 * @since 2.14.0
  1475. 	 */
  1476. 	public function sanitize_position_field( $data ) {
  1478. 		$sanitized_data = [];
  1480. 		if ( ! isset( $data['ruleGroups'] ) ) {
  1481. 			return new \WP_Error(
  1482. 				'wpbuddy/rich_snippets/rest/sanitize_field_position',
  1483. 				__( 'An array with a "ruleGroups" key is needed.', 'rich-snippets-schema' )
  1484. 			);
  1485. 		}
  1487. 		$i = - 1;
  1488. 		foreach ( $data['ruleGroups'] as $rule_group ) {
  1489. 			if ( ! isset( $rule_group['rules'] ) ) {
  1490. 				continue;
  1491. 			}
  1493. 			$i ++;
  1494. 			foreach ( $rule_group['rules'] as $rule ) {
  1495. 				if ( ! isset( $rule['param'] ) ) {
  1496. 					continue;
  1497. 				}
  1498. 				if ( ! isset( $rule['operator'] ) ) {
  1499. 					continue;
  1500. 				}
  1501. 				if ( ! isset( $rule['value'] ) ) {
  1502. 					continue;
  1503. 				}
  1505. 				$sanitized_data[ $i ][] = [
  1506. 					'param'    => sanitize_text_field( $rule['param'] ),
  1507. 					'operator' => sanitize_text_field( $rule['operator'] ),
  1508. 					'value'    => sanitize_text_field( $rule['value'] ),
  1509. 				];
  1511. 			}
  1512. 		}
  1514. 		return $sanitized_data;
  1515. 	}
  1518. 	/**
  1519. 	 * Updates the position field.
  1520. 	 *
  1521. 	 * @param                  $field_value
  1522. 	 * @param \WP_Post $object
  1523. 	 * @param string $field_name
  1524. 	 * @param \WP_REST_Request $request
  1525. 	 * @param string $object_type
  1526. 	 *
  1527. 	 * @return bool|\WP_Error
  1528. 	 * @since 2.14.0
  1529. 	 */
  1530. 	public function update_position_field( $field_value, $object, $field_name, $request, $object_type ) {
  1532. 		$ruleset = new Position_Ruleset();
  1534. 		foreach ( $field_value as $rule_group ) {
  1536. 			$new_rule_group = new Position_Rule_Group();
  1538. 			foreach ( $rule_group['rules'] as $rule ) {
  1539. 				if ( ! isset( $rule['param'] ) ) {
  1540. 					continue;
  1541. 				}
  1542. 				if ( ! isset( $rule['operator'] ) ) {
  1543. 					continue;
  1544. 				}
  1545. 				if ( ! isset( $rule['value'] ) ) {
  1546. 					continue;
  1547. 				}
  1549. 				$new_rule           = new Position_Rule();
  1550. 				$new_rule->param    = sanitize_text_field( $rule['param'] );
  1551. 				$new_rule->operator = sanitize_text_field( $rule['operator'] );
  1552. 				$new_rule->value    = sanitize_text_field( $rule['value'] );
  1554. 				$new_rule_group->add_rule( $new_rule );
  1555. 			}
  1557. 			$ruleset->add_rulegroup( $new_rule_group );
  1558. 		}
  1560. 		$updated = Rules_Model::update_ruleset( $object->ID, $ruleset );
  1562. 		if ( false === $updated ) {
  1563. 			return new \WP_Error(
  1564. 				'wpbuddy/rich_snippets/rest/get_field',
  1565. 				__( 'An error occurred during the update.', 'rich-snippets-schema' ),
  1566. 				[
  1567. 					'value' => $field_value,
  1568. 				]
  1569. 			);
  1570. 		}
  1572. 		return true;
  1573. 	}
  1576. 	/**
  1577. 	 * Get recommended schemas.
  1578. 	 *
  1579. 	 * @param \WP_REST_Request $request
  1580. 	 *
  1581. 	 * @return \WP_REST_Response|\WP_Error
  1582. 	 * @since 2.14.0
  1583. 	 *
  1584. 	 */
  1585. 	public function get_recommended_schemas() {
  1587. 		$recommendations = [];
  1589. 		/**
  1590. 		 * Check for WooCommerce
  1591. 		 */
  1592. 		if ( function_exists( 'WC' ) ) {
  1593. 			$recommendations['product'] = [
  1594. 				'detectedPlugin' => 'WooCommerce'
  1595. 			];
  1596. 		}
  1598. 		/**
  1599. 		 * Check if blog has blog posts
  1600. 		 */
  1601. 		$post_count = wp_count_posts( 'post' );
  1603. 		if ( $post_count->publish > 0 ) {
  1604. 			$recommendations['article'] = [
  1605. 				'detectedPlugin' => 'WordPress Core'
  1606. 			];
  1607. 		}
  1609. 		/**
  1610. 		 * Check if blog has pages
  1611. 		 */
  1612. 		if ( ! isset( $recommendations['article'] ) ) {
  1613. 			$page_count = wp_count_posts( 'page' );
  1615. 			if ( $page_count->publish > 0 ) {
  1616. 				$recommendations['article'] = [
  1617. 					'detectedPlugin' => 'WordPress Core'
  1618. 				];
  1619. 			}
  1620. 		}
  1622. 		/**
  1623. 		 * Check for WP Event Manager
  1624. 		 * @see https://de.wordpress.org/plugins/wp-event-manager/
  1625. 		 */
  1626. 		if ( function_exists( '\WPEM' ) ) {
  1627. 			$recommendations['event'] = [
  1628. 				'detectedPlugin' => 'WP Event Manager'
  1629. 			];
  1630. 		}
  1632. 		/**
  1633. 		 * Check for The Events Calendar
  1634. 		 * @see https://de.wordpress.org/plugins/the-events-calendar/
  1635. 		 */
  1636. 		if ( ! isset( $recommendations['event'] ) && defined( 'TRIBE_EVENTS_FILE' ) ) {
  1637. 			$recommendations['event'] = [
  1638. 				'detectedPlugin' => 'The Events Calendar'
  1639. 			];
  1640. 		}
  1642. 		/**
  1643. 		 * Check for WP Ultimate Recipe
  1644. 		 * @see https://de.wordpress.org/plugins/wp-ultimate-recipe/
  1645. 		 */
  1646. 		if ( ! isset( $recommendations['event'] ) && ( class_exists( '\WPUltimateRecipe' ) || class_exists( '\WPUltimateRecipePremium' ) ) ) {
  1647. 			$recommendations['event'] = [
  1648. 				'detectedPlugin' => 'WP Ultimate Recipe'
  1649. 			];
  1650. 		}
  1652. 		return rest_ensure_response( $recommendations );
  1653. 	}
  1656. 	/**
  1657. 	 * Searches for SNIP examples.
  1658. 	 *
  1659. 	 * @param \WP_REST_Request $request
  1660. 	 *
  1661. 	 * @return mixed|\WP_REST_Response
  1662. 	 * @since 2.14.0
  1663. 	 */
  1664. 	public function get_schema_type_examples( $request ) {
  1665. 		$schema = $request->get_param( 'type' );
  1666. 		$ids    = $request->get_param( 'ids' );
  1668. 		/**
  1669. 		 * Get the TERM ID
  1670. 		 */
  1671. 		if ( $schema ) {
  1672. 			$response = WPBuddy_Model::request(
  1673. 				'/wp/v2/schema?per_page=1&search=' . Helper_Model::instance()->remove_schema_url( $schema )
  1674. 			);
  1677. 			if ( is_wp_error( $response ) ) {
  1678. 				return $response;
  1679. 			}
  1681. 			if ( ! is_array( $response ) ) {
  1682. 				return new \WP_Error(
  1683. 					'wpbuddy/rich_snippets/rest/schema_examples',
  1684. 					__( 'The WP-Buddy API returned an error while SNIP was searching for examples.', 'rich-snippets-schema' )
  1685. 				);
  1686. 			}
  1688. 			if ( ! is_array( $response ) || ( is_array( $response ) && count( $response ) <= 0 ) ) {
  1689. 				return new \WP_Error(
  1690. 					'wpbuddy/rich_snippets/rest/schema_examples',
  1691. 					__( 'The WP-Buddy API did not return any Term-IDs to request for examples.', 'rich-snippets-schema' )
  1692. 				);
  1693. 			}
  1695. 			$tax_schema = reset( $response );
  1697. 			$response = WPBuddy_Model::request(
  1698. 				'/wp/v2/wpb-rs-sync?schema=' . $tax_schema->id
  1699. 			);
  1700. 		} elseif ( $ids ) {
  1701. 			$ids      = array_map( function ( $id ) {
  1702. 				return sprintf( 'include[]=%d', $id );
  1703. 			}, $ids );
  1704. 			$response = WPBuddy_Model::request(
  1705. 				'/wp/v2/wpb-rs-sync?per_page=100&' . implode( '&', $ids )
  1706. 			);
  1707. 		} else {
  1708. 			return new \WP_Error(
  1709. 				'wpbuddy/rich_snippets/rest/schema_examples',
  1710. 				_x( 'Either type or ids must be entered.', 'rich-snippets-schema' )
  1711. 			);
  1712. 		}
  1714. 		if ( is_wp_error( $response ) ) {
  1715. 			return $response;
  1716. 		}
  1718. 		if ( ! is_array( $response ) ) {
  1719. 			return new \WP_Error(
  1720. 				'wpbuddy/rich_snippets/rest/schema_examples',
  1721. 				_x( 'The WP-Buddy API did not return any SNIPs.', 'Thrown error on rest api when there were no snip examples found.', 'rich-snippets-schema' )
  1722. 			);
  1723. 		}
  1725. 		$ret = array_map( function ( $obj ) {
  1727. 			$o               = new \stdClass();
  1728. 			$o->id           = intval( $obj->id );
  1729. 			$o->title        = sanitize_text_field( $obj->title->rendered );
  1730. 			$o->link         = esc_url( $obj->link );
  1731. 			$o->snip_code    = $obj->snip_code;
  1732. 			$o->excerpt      = sanitize_text_field( $obj->excerpt->rendered );
  1733. 			$o->dependencies = array_map( 'intval', (array) $obj->snip_dependencies );
  1735. 			return $o;
  1737. 		}, $response );
  1739. 		$ret = array_filter( $ret );
  1741. 		return rest_ensure_response( $ret );
  1742. 	}
  1745. 	/**
  1746. 	 * Loads a position value select box (HTML code).
  1747. 	 *
  1748. 	 * @param \WP_REST_Request $request
  1749. 	 *
  1750. 	 * @return mixed|\WP_REST_Response
  1751. 	 * @since 2.0.0
  1752. 	 */
  1753. 	public function load_position_value_select( $request ) {
  1755. 		$rule        = new Position_Rule();
  1756. 		$rule->param = $request->get_param( 'param' );
  1758. 		ob_start();
  1759. 		Admin_Position_Controller::instance()->print_value_select( $rule );
  1761. 		return rest_ensure_response( array(
  1762. 			'select_html' => ob_get_clean(),
  1763. 		) );
  1764. 	}
  1766. 	/**
  1767. 	 * Returns the positions value select options.
  1768. 	 *
  1769. 	 * @param \WP_REST_Request $request
  1770. 	 *
  1771. 	 * @return mixed|\WP_REST_Response
  1772. 	 * @since 2.14.0
  1773. 	 *
  1774. 	 */
  1775. 	public function load_position_value_select_options( $request ) {
  1777. 		$rule        = new Position_Rule();
  1778. 		$rule->param = $request->get_param( 'param' );
  1780. 		$options = Admin_Position_Controller::instance()->get_value_select_options( $rule );
  1782. 		return rest_ensure_response( $options );
  1783. 	}
  1786. 	/**
  1787. 	 * Loads values for a position value select2 box.
  1788. 	 *
  1789. 	 * @param \WP_REST_Request $request
  1790. 	 *
  1791. 	 * @return mixed|\WP_REST_Response
  1792. 	 * @since 2.0.0
  1793. 	 *
  1794. 	 */
  1795. 	public function load_position_value_possibilities( $request ) {
  1797. 		$q     = $request->get_param( 'q' );
  1798. 		$page  = $request->get_param( 'page' );
  1799. 		$param = $request->get_param( 'param' );
  1801. 		$values = array();
  1803. 		$i18n = _x(
  1804. 			'%1$s (%2$s, %3$d)',
  1805. 			'value possibilities: %1$s is the post title, %2$s is the post type, %3$d is the post ID',
  1806. 			'rich-snippets-schema'
  1807. 		);
  1809. 		switch ( $param ) {
  1810. 			case 'user':
  1811. 				global $wpdb;
  1812. 				/**
  1813. 				 * @var \WP_User[] $users
  1814. 				 */
  1815. 				$users = get_users( [
  1816. 					'search'         => '*' . $q . '*',
  1817. 					'search_columns' => [
  1818. 						'ID',
  1819. 						'user_login',
  1820. 						'user_email',
  1821. 						'user_nicename',
  1822. 						'display_name'
  1823. 					]
  1824. 				] );
  1826. 				foreach ( $users as $user ) {
  1827. 					$values[ $user->ID ] = sprintf(
  1828. 						$i18n,
  1829. 						esc_attr( $user->user_login ),
  1830. 						'user',
  1831. 						$user->ID
  1832. 					);
  1833. 				}
  1834. 				break;
  1835. 			case 'post':
  1836. 			case 'page_parent':
  1837. 			default:
  1838. 				global $wpdb;
  1840. 				$sql = "SELECT ID, post_title, post_type FROM {$wpdb->posts} WHERE ";
  1842. 				if ( false !== stripos( $q, 'id:' ) ) {
  1843. 					$q   = (int) str_replace( 'id:', '', $q );
  1844. 					$sql .= 'ID = %d';
  1845. 					$sql = $wpdb->prepare( $sql, $q );
  1846. 				} else {
  1847. 					$like = sprintf( '%%%s%%', $wpdb->esc_like( $q ) );
  1848. 					$sql  .= "(post_title LIKE '%s' OR ID = %d) AND post_status = 'publish'";
  1850. 					$sql = $wpdb->prepare( $sql, esc_sql( $like ), $q );
  1851. 				}
  1854. 				if ( 'page_parent' === $param ) {
  1855. 					$sql .= ' AND post_type = "page"';
  1856. 				}
  1858. 				$posts = $wpdb->get_results( $sql );
  1860. 				if ( ! is_array( $posts ) ) {
  1861. 					return rest_ensure_response( array(
  1862. 						'values' => array(),
  1863. 					) );
  1864. 				}
  1866. 				foreach ( $posts as $post ) {
  1867. 					$post_title = empty( $post->post_title ) ? __( '(No post title)', 'rich-snippets-schema' ) : $post->post_title;
  1869. 					$values[ $post->ID ] = sprintf(
  1870. 						$i18n,
  1871. 						esc_attr( $post_title ),
  1872. 						esc_attr( $post->post_type ),
  1873. 						$post->ID
  1874. 					);
  1875. 				}
  1876. 		}
  1878. 		/**
  1879. 		 * Position value possibilities filter.
  1880. 		 *
  1881. 		 * Allows to modify the list of possible values for positions.
  1882. 		 *
  1883. 		 * @hook  wpbuddy/rich_snippets/position/value_possibilities
  1884. 		 *
  1885. 		 * @param {array} $values The possible values.
  1886. 		 * @param {string} $q The search term.
  1887. 		 * @param {int} $page The page number.
  1888. 		 * @param {string} $param
  1889. 		 *
  1890. 		 * @returns {array} A list of possible position values.
  1891. 		 *
  1892. 		 * @since 2.0.0
  1893. 		 */
  1894. 		$values = apply_filters( 'wpbuddy/rich_snippets/position/value_possibilities', $values, $q, $page, $param );
  1896. 		return rest_ensure_response( array(
  1897. 			'values' => $values,
  1898. 		) );
  1899. 	}
  1901. 	/**
  1902. 	 * Imports SNIPs that were found on rich-snippets.io
  1903. 	 *
  1904. 	 * @param \WP_REST_Request $request
  1905. 	 *
  1906. 	 * @return mixed|\WP_REST_Response
  1907. 	 * @since 2.14.0
  1908. 	 */
  1909. 	public function snips_import( $request ) {
  1910. 		global $wpdb;
  1911. 		$snipIds    = $request->get_param( 'snips' );
  1912. 		$properties = $request->get_param( 'properties' );
  1913. 		$rulesets   = $request->get_param( 'rulesets' );
  1915. 		$get_schemas = function ( $snip_ids ) {
  1916. 			$snip_ids = array_unique( $snip_ids );
  1917. 			$response = WPBuddy_Model::request(
  1918. 				'/wp/v2/wpb-rs-sync?include=' . implode( ',', $snip_ids )
  1919. 			);
  1921. 			if ( is_wp_error( $response ) ) {
  1922. 				return $response;
  1923. 			}
  1925. 			if ( ! is_array( $response ) ) {
  1926. 				return new \WP_Error(
  1927. 					'wpbuddy/rich_snippets/rest/snips_import',
  1928. 					_x( 'The WP-Buddy API did not return any SNIPs.', 'Thrown error on rest api when there were no snip examples found.', 'rich-snippets-schema' )
  1929. 				);
  1930. 			}
  1932. 			return $response;
  1933. 		};
  1935. 		$response = $get_schemas( $snipIds );
  1937. 		if ( is_wp_error( $response ) ) {
  1938. 			return $response;
  1939. 		}
  1941. 		$messages = [];
  1943. 		$dependencies = [];
  1945. 		foreach ( $response as $snip ) {
  1946. 			if ( ! isset( $snip->snip_dependencies ) ) {
  1947. 				continue;
  1948. 			}
  1950. 			if ( ! is_array( $snip->snip_dependencies ) ) {
  1951. 				continue;
  1952. 			}
  1954. 			if ( count( $snip->snip_dependencies ) <= 0 ) {
  1955. 				continue;
  1956. 			}
  1958. 			$dependencies = array_merge_recursive( $dependencies, array_map( 'intval', $snip->snip_dependencies ) );
  1959. 		}
  1961. 		if ( count( $dependencies ) > 0 ) {
  1962. 			$response2 = $get_schemas( $dependencies );
  1964. 			if ( is_wp_error( $response2 ) ) {
  1965. 				return $response2;
  1966. 			}
  1968. 			$response = array_merge_recursive( $response, $response2 );
  1969. 		}
  1971. 		foreach ( $response as $snip ) {
  1972. 			$snip_id = intval( $snip->id );
  1974. 			$query       = $wpdb->prepare( "SELECT post_id FROM {$wpdb->postmeta} as pm LEFT JOIN {$wpdb->posts} as p ON (pm.post_id = p.ID) WHERE pm.meta_key = '_wpb_rs_sync_id' AND pm.meta_value = %d AND p.post_status = 'publish' LIMIT 1", $snip_id );
  1975. 			$post_id     = $wpdb->get_var( $query );
  1976. 			$is_new_post = false;
  1978. 			# Create a new Global Snippet if it does not exist
  1979. 			if ( is_null( $post_id ) ) {
  1980. 				$post_id = wp_insert_post( [
  1981. 					'post_type'   => 'wpb-rs-global',
  1982. 					'post_title'  => sanitize_text_field( $snip->title->rendered ),
  1983. 					'post_status' => 'publish',
  1984. 					'meta_input'  => [
  1985. 						'_wpb_rs_sync_id' => intval( $snip_id )
  1986. 					]
  1987. 				] );
  1989. 				if ( is_wp_error( $post_id ) ) {
  1990. 					$messages[ $snip_id ] = new \WP_Error(
  1991. 						'wpbuddy/rich_snippets/rest/snips_import',
  1992. 						sprintf(
  1993. 							__( 'Could not create global snippet during SNIP import. Got error: %s', 'rich-snippets-schema' ),
  1994. 							$post_id->get_error_message()
  1995. 						)
  1996. 					);
  1997. 					continue;
  1998. 				}
  2000. 				$is_new_post = true;
  2001. 			}
  2003. 			$post_id = intval( $post_id );
  2005. 			if ( is_null( $snip->snip_code ) ) {
  2006. 				if ( $is_new_post ) {
  2007. 					# delete previously created post
  2008. 					wp_delete_post( $post_id, true );
  2009. 				}
  2011. 				$messages[ $snip_id ] = new \WP_Error(
  2012. 					'wpbuddy/rich_snippets/rest/snips_import',
  2013. 					__( 'Could not decode SNIP. No Global Snippet was created.', 'rich-snippets-schema' )
  2014. 				);
  2016. 				continue;
  2017. 			}
  2019. 			/**
  2020. 			 * Now write all the post meta
  2021. 			 */
  2023. 			$snippet = json_decode( json_encode( $snip->snip_code ), true );
  2025. 			if ( isset( $snippet['@ruleset'] ) ) {
  2026. 				$rules_array = $snippet['@ruleset'];
  2027. 				unset( $snippet['@ruleset'] );
  2028. 			} else {
  2029. 				$rules_array = [];
  2030. 			}
  2032. 			# the snippet
  2033. 			$snippet = Snippets_Model::convert_from_json( $snippet );
  2035. 			# merge properties
  2036. 			if ( array_key_exists( $snip_id, $properties ) ) {
  2037. 				$snippet = Snippets_Model::merge_props_into_schema( $snippet, $properties[ $snip_id ] );
  2038. 			}
  2040. 			Snippets_Model::update_snippets( $post_id, [ $snippet ] );
  2042. 			if ( ! is_array( $rules_array ) ) {
  2043. 				continue;
  2044. 			}
  2046. 			$rules_array = array_filter( $rules_array );
  2048. 			if ( count( $rules_array ) <= 0 ) {
  2049. 				continue;
  2050. 			}
  2052. 			$ruleset = Rules_Model::sanitize_and_convert_to_ruleset( $rules_array );
  2053. 			Rules_Model::update_ruleset( $post_id, $ruleset );
  2055. 			if ( $is_new_post ) {
  2056. 				$messages[ $snip_id ] = sprintf(
  2057. 					__( 'Created Global Snippet "%s".', 'rich-snippets-schema' ),
  2058. 					sanitize_text_field( $snip->title->rendered )
  2059. 				);
  2060. 			} else {
  2061. 				$messages[ $snip_id ] = sprintf(
  2062. 					__( 'Updated Global Snippet "%s".', 'rich-snippets-schema' ),
  2063. 					get_the_title( $post_id )
  2064. 				);
  2065. 			}
  2067. 		}
  2069. 		if ( isset( $response2 ) ) {
  2070. 			$messages[999999] = __( 'Some snippets were installed because they are dependent on others.', 'rich-snippets-schema' );
  2071. 		}
  2073. 		return rest_ensure_response( $messages );
  2074. 	}
  2075. }