Tiny File Manager | class-simple-page-ordering.php

Back Back Up Advanced Editor

<?php

namespace SimplePageOrdering;

use stdClass;
use WP_Error;
use WP_Post;
use WP_REST_Response;
use WP_Query;

// Useful global constants.
define( 'SIMPLE_PAGE_ORDERING_VERSION', '2.7.2' );

if ( ! class_exists( 'Simple_Page_Ordering' ) ) :

/**
	 * Simple_Page_Ordering class
	 */
	class Simple_Page_Ordering {

/**
		 * Handles initializing this class and returning the singleton instance after it's been cached.
		 *
		 * @return null|Simple_Page_Ordering
		 */
		public static function get_instance() {
			// Store the instance locally to avoid private static replication
			static $instance = null;

if ( null === $instance ) {
				$instance = new self();
				self::add_actions();
			}

return $instance;
		}

/**
		 * An empty constructor
		 *
		 * Purposely do nothing here
		 */
		public function __construct() {}

/**
		 * Handles registering hooks that initialize this plugin.
		 */
		public static function add_actions() {
			add_action( 'load-edit.php', array( __CLASS__, 'load_edit_screen' ) );
			add_action( 'wp_ajax_simple_page_ordering', array( __CLASS__, 'ajax_simple_page_ordering' ) );
			add_action( 'wp_ajax_reset_simple_page_ordering', array( __CLASS__, 'ajax_reset_simple_page_ordering' ) );
			add_action( 'plugins_loaded', array( __CLASS__, 'load_textdomain' ) );
			add_action( 'rest_api_init', array( __CLASS__, 'rest_api_init' ) );

// Custom edit page actions.
			add_action( 'post_action_spo-move-under-grandparent', array( __CLASS__, 'handle_move_under_grandparent' ) );
			add_action( 'post_action_spo-move-under-sibling', array( __CLASS__, 'handle_move_under_sibling' ) );
		}

/**
		 * Move a post in/up the post parent tree.
		 *
		 * This is a custom action on the edit page to modify the post parent
		 * to be the child it's current grandparent post. If no grandparent
		 * exists, the post becomes a top level page.
		 *
		 * @param int $post_id The post ID.
		 */
		public static function handle_move_under_grandparent( $post_id ) {
			$post = get_post( $post_id );
			if ( ! $post ) {
				self::redirect_to_referer();
			}

check_admin_referer( "simple-page-ordering-nonce-move-{$post->ID}", 'spo_nonce' );

if ( ! current_user_can( 'edit_post', $post->ID ) ) {
				wp_die( esc_html__( 'You are not allowed to edit this item.', 'simple-page-ordering' ) );
			}

if ( 0 === $post->post_parent ) {
				// Top level. Politely continue without doing anything.
				self::redirect_to_referer();
			}

$ancestors = get_post_ancestors( $post );

// If only one ancestor, set to top level page.
			if ( 1 === count( $ancestors ) ) {
				$parent_id = 0;
			} else {
				$parent_id = $ancestors[1];
			}

// Update the post.
			wp_update_post(
				array(
					'ID'          => $post->ID,
					'post_parent' => $parent_id,
				)
			);

self::redirect_to_referer();
		}

/**
		 * Move a post out/down the post parent tree.
		 *
		 * This is a custom action on the edit page to modify the post parent
		 * to be the child of it's previous sibling post on the current post
		 * tree.
		 *
		 * @param int $post_id The post ID.
		 */
		public static function handle_move_under_sibling( $post_id ) {
			$post = get_post( $post_id );
			if ( ! $post ) {
				self::redirect_to_referer();
			}

check_admin_referer( "simple-page-ordering-nonce-move-{$post->ID}", 'spo_nonce' );

if ( ! current_user_can( 'edit_post', $post->ID ) ) {
				wp_die( esc_html__( 'You are not allowed to edit this item.', 'simple-page-ordering' ) );
			}

list( 'top_level_pages' => $top_level_pages, 'children_pages' => $children_pages ) = self::get_walked_pages( $post->post_type );

// Get the relevant siblings.
			if ( 0 === $post->post_parent ) {
				$siblings = $top_level_pages;
			} else {
				$siblings = $children_pages[ $post->post_parent ];
			}

// Check if the post being moved is a top level page.
			$filtered_siblings = wp_list_filter( $siblings, array( 'ID' => $post->ID ) );
			if ( empty( $filtered_siblings ) ) {
				// Something went wrong. Do nothing.
				self::redirect_to_referer();
			}

// Find the previous page in the sibling tree
			$key = array_key_first( $filtered_siblings );
			if ( 0 === $key ) {
				// It's the first page. Do nothing.
				self::redirect_to_referer();
			}

$previous_page    = $siblings[ $key - 1 ];
			$previous_page_id = $previous_page->ID;

// Update the post with the previous page as the parent.
			wp_update_post(
				array(
					'ID'          => $post->ID,
					'post_parent' => $previous_page_id,
				)
			);

self::redirect_to_referer();
		}

/**
		 * Redirect the user after modifying the post parent.
		 */
		public static function redirect_to_referer() {
			global $post_type;

$send_back = wp_get_referer();
			if ( ! $send_back ||
				str_contains( $send_back, 'post.php' ) ||
				str_contains( $send_back, 'post-new.php' ) ) {
				if ( 'attachment' === $post_type ) {
					$send_back = admin_url( 'upload.php' );
				} else {
					$send_back = admin_url( 'edit.php' );
					if ( ! empty( $post_type ) ) {
						$send_back = add_query_arg( 'post_type', $post_type, $send_back );
					}
				}
			} else {
				$send_back = remove_query_arg( array( 'trashed', 'untrashed', 'deleted', 'ids' ), $send_back );
			}

wp_safe_redirect( $send_back );
			exit;
		}

/**
		 * Walk the pages and return top level and children pages.
		 *
		 * @param string $post_type Post type to walk.
		 *
		 * @return array {
		 *    @type WP_Post[] $top_level_pages Top level pages.
		 *    @type WP_Post[] $children_pages  Children pages.
		 * }
		 */
		public static function get_walked_pages( $post_type = 'page' ) {
			global $wpdb;
			$pages = get_pages(
				array(
					'sort_column' => 'menu_order title',
					'post_type'   => $post_type,
				)
			);

$top_level_pages = array();
			$children_pages  = array();
			$bad_parents     = array();

foreach ( $pages as $page ) {
				// Catch and repair bad pages.
				if ( $page->post_parent === $page->ID ) {
					$page->post_parent = 0;
					$wpdb->update( $wpdb->posts, array( 'post_parent' => 0 ), array( 'ID' => $page->ID ) );
					clean_post_cache( $page );
					$bad_parents[] = $page->ID;
				}

if ( $page->post_parent > 0 ) {
					$children_pages[ $page->post_parent ][] = $page;
				} else {
					$top_level_pages[] = $page;
				}
			}
			// Reprime post cache for bad parents.
			_prime_post_caches( $bad_parents, false, false );

return array(
				'top_level_pages' => $top_level_pages,
				'children_pages'  => $children_pages,
			);
		}

/**
		 * Loads the plugin textdomain
		 */
		public static function load_textdomain() {
			load_plugin_textdomain( 'simple-page-ordering', false, dirname( plugin_basename( __FILE__ ) ) . '/localization/' );
		}

/**
		 * Determine whether given post type is sortable or not.
		 *
		 * @param string $post_type Post type to check.
		 *
		 * @return boolean
		 */
		private static function is_post_type_sortable( $post_type = 'post' ) {
			$sortable = ( post_type_supports( $post_type, 'page-attributes' ) || is_post_type_hierarchical( $post_type ) );

/**
			 * Change default ordering support for a post type.
			 *
			 * @since 2.0.0
			 *
			 * @param boolean $sortable Whether this post type is sortable or not.
			 * @param string  $post_type The post type being checked.
			 */
			return apply_filters( 'simple_page_ordering_is_sortable', $sortable, $post_type );
		}

/**
		 * Load up page ordering scripts for the edit screen
		 */
		public static function load_edit_screen() {
			$screen    = get_current_screen();
			$post_type = $screen->post_type;

// is post type sortable?
			$sortable = self::is_post_type_sortable( $post_type );
			if ( ! $sortable ) {
				return;
			}

// does user have the right to manage these post objects?
			if ( ! self::check_edit_others_caps( $post_type ) ) {
				return;
			}

// add view by menu order to views
			add_filter(
				'views_' . $screen->id,
				array(
					__CLASS__,
					'sort_by_order_link',
				)
			);
			add_action( 'pre_get_posts', array( __CLASS__, 'filter_query' ) );
			add_action( 'wp', array( __CLASS__, 'wp' ) );
			add_action( 'admin_head', array( __CLASS__, 'admin_head' ) );
			add_action( 'page_row_actions', array( __CLASS__, 'page_row_actions' ), 10, 2 );
		}

/**
		 * This is to enable pagination.
		 *
		 * @param WP_Query $query The WP_Query instance (passed by reference).
		 */
		public static function filter_query( $query ) {
			if ( ! $query->is_main_query() ) {
				return;
			}

// phpcs:ignore WordPress.Security.NonceVerification.Recommended
			$is_simple_page_ordering = isset( $_GET['id'] ) ? 'simple-page-ordering' === $_GET['id'] : false;

if ( ! $is_simple_page_ordering ) {
				return;
			}

$query->set( 'posts_per_page', -1 );
		}

/**
		 * when we load up our posts query, if we're actually sorting by menu order, initialize sorting scripts
		 */
		public static function wp() {
			$orderby   = get_query_var( 'orderby' );
			$screen    = get_current_screen();
			$post_type = $screen->post_type ?? 'post';

if ( ( is_string( $orderby ) && 0 === strpos( $orderby, 'menu_order' ) ) || ( isset( $orderby['menu_order'] ) && 'ASC' === $orderby['menu_order'] ) ) {

$script_name       = 'dist/js/simple-page-ordering.js';
				$script_asset_path = plugin_dir_path( __FILE__ ) . 'dist/js/simple-page-ordering.asset.php';
				$script_asset      = file_exists( $script_asset_path )
					? require $script_asset_path
					: false;

if ( false !== $script_asset ) {
					$script_url = plugins_url( $script_name, __FILE__ );
					wp_enqueue_script( 'simple-page-ordering', $script_url, $script_asset['dependencies'], $script_asset['version'], true );

wp_localize_script(
						'simple-page-ordering',
						'simple_page_ordering_localized_data',
						array(
							'_wpnonce'         => wp_create_nonce( 'simple-page-ordering-nonce' ),
							/* translators: %1$s is replaced with the post type name */
							'confirmation_msg' => sprintf( esc_html__( 'Are you sure you want to reset the ordering of the "%1$s" post type?', 'simple-page-ordering' ), $post_type ),
						)
					);

wp_enqueue_style( 'simple-page-ordering', plugins_url( '/dist/css/simple-page-ordering.css', __FILE__ ), [], $script_asset['version'] );
				} else {
					add_action(
						'admin_notices',
						function () {
							?>
							<div class="notice notice-warning is-dismissible">
								<p><?php echo wp_kses_post( __( 'It looks like you are using a development copy of <strong>Simple Page Ordering</strong>. Please run <code>npm i; npm run build</code> to create assets.', 'simple-page-ordering' ) ); ?></p>
							</div>
							<?php
						}
					);
				}
			}
		}

/**
		 * Add page ordering help to the help tab
		 */
		public static function admin_head() {
			$screen    = get_current_screen();
			$post_type = $screen->post_type ?? 'post';

$screen->add_help_tab(
				array(
					'id'      => 'simple_page_ordering_help_tab',
					'title'   => esc_html__( 'Simple Page Ordering', 'simple-page-ordering' ),
					'content' => sprintf(
						'<p>%s</p><a href="#" id="simple-page-ordering-reset" data-posttype="%s">%s</a>',
						esc_html__( 'To reposition an item, simply drag and drop the row by "clicking and holding" it anywhere (outside of the links and form controls) and moving it to its new position.', 'simple-page-ordering' ),
						esc_attr( get_query_var( 'post_type' ) ),
						/* translators: %1$s is replaced with the post type name */
						sprintf( esc_html__( 'Reset %1$s order', 'simple-page-ordering' ), $post_type )
					),
				)
			);
		}

/**
		 * Modify the row actions for hierarchical post types.
		 *
		 * This adds the actions to change the parent/child relationships.
		 *
		 * @param array   $actions An array of row action links.
		 * @param WP_Post $post    The post object.
		 */
		public static function page_row_actions( $actions, $post ) {
			$post = get_post( $post );
			if ( ! $post ) {
				return $actions;
			}

if ( ! current_user_can( 'edit_post', $post->ID ) ) {
				return $actions;
			}

list( 'top_level_pages' => $top_level_pages, 'children_pages' => $children_pages ) = self::get_walked_pages( $post->post_type );

$edit_link                   = get_edit_post_link( $post->ID, 'raw' );
			$move_under_grandparent_link = add_query_arg(
				array(
					'action'    => 'spo-move-under-grandparent',
					'spo_nonce' => wp_create_nonce( "simple-page-ordering-nonce-move-{$post->ID}" ),
					'post_type' => $post->post_type,
				),
				$edit_link
			);
			$move_under_sibling_link     = add_query_arg(
				array(
					'action'    => 'spo-move-under-sibling',
					'spo_nonce' => wp_create_nonce( "simple-page-ordering-nonce-move-{$post->ID}" ),
					'post_type' => $post->post_type,
				),
				$edit_link
			);

$parent_id = $post->post_parent;
			if ( $parent_id ) {
				$actions['spo-move-under-grandparent'] = sprintf(
					'<a href="%s">%s</a>',
					esc_url( $move_under_grandparent_link ),
					sprintf(
						/* translators: %s: parent page/post title */
						__( 'Move out from under %s', 'simple-page-ordering' ),
						get_the_title( $parent_id )
					)
				);
			}

// Get the relevant siblings.
			if ( 0 === $post->post_parent ) {
				$siblings = $top_level_pages;
			} else {
				$siblings = $children_pages[ $post->post_parent ] ?? [];
			}

// Assume no sibling.
			$sibling = 0;
			// Check if the post being moved is a top level page.
			$filtered_siblings = wp_list_filter( $siblings, array( 'ID' => $post->ID ) );
			if ( ! empty( $filtered_siblings ) ) {
				// Find the previous page in the sibling tree
				$key = array_key_first( $filtered_siblings );
				if ( 0 === $key ) {
					// It's the first page, can't do anything.
					$sibling = 0;
				} else {
					$previous_page = $siblings[ $key - 1 ];
					$sibling       = $previous_page->ID;
				}
			}

if ( $sibling ) {
				$actions['spo-move-under-sibling'] = sprintf(
					'<a href="%s">%s</a>',
					esc_url( $move_under_sibling_link ),
					sprintf(
						/* translators: %s: sibling page/post title */
						__( 'Move under %s', 'simple-page-ordering' ),
						get_the_title( $sibling )
					)
				);
			}

return $actions;
		}

/**
		 * Page ordering ajax callback
		 *
		 * @return void
		 */
		public static function ajax_simple_page_ordering() {
			// check and make sure we have what we need
			if ( empty( $_POST['id'] ) || ( ! isset( $_POST['previd'] ) && ! isset( $_POST['nextid'] ) ) ) {
				die( - 1 );
			}

$nonce = isset( $_POST['_wpnonce'] ) ? sanitize_key( wp_unslash( $_POST['_wpnonce'] ) ) : '';

if ( ! wp_verify_nonce( $nonce, 'simple-page-ordering-nonce' ) ) {
				die( -1 );
			}

$post_id  = empty( $_POST['id'] ) ? false : (int) $_POST['id'];
			$previd   = empty( $_POST['previd'] ) ? false : (int) $_POST['previd'];
			$nextid   = empty( $_POST['nextid'] ) ? false : (int) $_POST['nextid'];
			$start    = empty( $_POST['start'] ) ? 1 : (int) $_POST['start'];
			$excluded = empty( $_POST['excluded'] ) ? array( $_POST['id'] ) : array_filter( (array) json_decode( $_POST['excluded'] ), 'intval' );

// real post?
			$post = empty( $post_id ) ? false : get_post( (int) $post_id );
			if ( ! $post ) {
				die( - 1 );
			}

// does user have the right to manage these post objects?
			if ( ! self::check_edit_others_caps( $post->post_type ) ) {
				die( - 1 );
			}

$result = self::page_ordering( $post_id, $previd, $nextid, $start, $excluded );

if ( is_wp_error( $result ) ) {
				die( -1 );
			}

die( wp_json_encode( $result ) );
		}

/**
		 * Page ordering reset ajax callback
		 *
		 * @return void
		 */
		public static function ajax_reset_simple_page_ordering() {
			global $wpdb;

$nonce = isset( $_POST['_wpnonce'] ) ? sanitize_key( wp_unslash( $_POST['_wpnonce'] ) ) : '';

if ( ! wp_verify_nonce( $nonce, 'simple-page-ordering-nonce' ) ) {
				die( -1 );
			}

// check and make sure we have what we need
			$post_type = isset( $_POST['post_type'] ) ? sanitize_text_field( wp_unslash( $_POST['post_type'] ) ) : '';

if ( empty( $post_type ) ) {
				die( -1 );
			}

// does user have the right to manage these post objects?
			if ( ! self::check_edit_others_caps( $post_type ) ) {
				die( -1 );
			}

// reset the order of all posts of given post type
			$wpdb->update( 'wp_posts', array( 'menu_order' => 0 ), array( 'post_type' => $post_type ), array( '%d' ), array( '%s' ) );

die( 0 );
		}

/**
		 * Page ordering function
		 *
		 * @param int   $post_id  The post ID.
		 * @param int   $previd   The previous post ID.
		 * @param int   $nextid   The next post ID.
		 * @param int   $start    The start index.
		 * @param array $excluded Array of post IDs.
		 *
		 * @return object|WP_Error|"children"
		 */
		public static function page_ordering( $post_id, $previd, $nextid, $start, $excluded ) {
			// real post?
			$post = empty( $post_id ) ? false : get_post( (int) $post_id );
			if ( ! $post ) {
				return new WP_Error( 'invalid', __( 'Missing mandatory parameters.', 'simple-page-ordering' ) );
			}

// Badly written plug-in hooks for save post can break things.
			if ( ! defined( 'WP_DEBUG' ) || ! WP_DEBUG ) {
				error_reporting( 0 ); // phpcs:ignore
			}

global $wp_version;

$previd   = empty( $previd ) ? false : (int) $previd;
			$nextid   = empty( $nextid ) ? false : (int) $nextid;
			$start    = empty( $start ) ? 1 : (int) $start;
			$excluded = empty( $excluded ) ? array( $post_id ) : array_filter( (array) $excluded, 'intval' );

$new_pos     = array(); // store new positions for ajax
			$return_data = new stdClass();

do_action( 'simple_page_ordering_pre_order_posts', $post, $start );

// attempt to get the intended parent... if either sibling has a matching parent ID, use that
			$parent_id        = $post->post_parent;
			$next_post_parent = $nextid ? wp_get_post_parent_id( $nextid ) : false;

if ( $previd === $next_post_parent ) {    // if the preceding post is the parent of the next post, move it inside
				$parent_id = $next_post_parent;
			} elseif ( $next_post_parent !== $parent_id ) {  // otherwise, if the next post's parent isn't the same as our parent, we need to study
				$prev_post_parent = $previd ? wp_get_post_parent_id( $previd ) : false;
				if ( $prev_post_parent !== $parent_id ) {    // if the previous post is not our parent now, make it so!
					$parent_id = ( false !== $prev_post_parent ) ? $prev_post_parent : $next_post_parent;
				}
			}

// if the next post's parent isn't our parent, it might as well be false (irrelevant to our query)
			if ( $next_post_parent !== $parent_id ) {
				$nextid = false;
			}

$max_sortable_posts = (int) apply_filters( 'simple_page_ordering_limit', 50 );    // should reliably be able to do about 50 at a time

if ( $max_sortable_posts < 5 ) {    // don't be ridiculous!
				$max_sortable_posts = 50;
			}

// we need to handle all post stati, except trash (in case of custom stati)
			$post_stati = get_post_stati(
				array(
					'show_in_admin_all_list' => true,
				)
			);

$siblings_query = array(
				'depth'                  => 1,
				'posts_per_page'         => $max_sortable_posts,
				'post_type'              => $post->post_type,
				'post_status'            => $post_stati,
				'post_parent'            => $parent_id,
				'post__not_in'           => $excluded, // phpcs:ignore
				'orderby'                => array(
					'menu_order' => 'ASC',
					'title'      => 'ASC',
				),
				'update_post_term_cache' => false,
				'update_post_meta_cache' => false,
				'suppress_filters'       => true, // phpcs:ignore WordPressVIPMinimum.Performance.WPQueryParams.SuppressFiltersTrue
				'ignore_sticky_posts'    => true,
			);

if ( version_compare( $wp_version, '4.0', '<' ) ) {
				$siblings_query['orderby'] = 'menu_order title';
				$siblings_query['order']   = 'ASC';
			}

$siblings = new WP_Query( $siblings_query ); // fetch all the siblings (relative ordering)

// don't waste overhead of revisions on a menu order change (especially since they can't *all* be rolled back at once)
			remove_action( 'post_updated', 'wp_save_post_revision' );

foreach ( $siblings->posts as $sibling ) :
				// don't handle the actual post
				if ( $sibling->ID === $post->ID ) {
					continue;
				}

// if this is the post that comes after our repositioned post, set our repositioned post position and increment menu order
				if ( $nextid === $sibling->ID ) {
					wp_update_post(
						array(
							'ID'          => $post->ID,
							'menu_order'  => $start,
							'post_parent' => $parent_id,
						)
					);

$ancestors            = get_post_ancestors( $post->ID );
					$new_pos[ $post->ID ] = array(
						'menu_order'  => $start,
						'post_parent' => $parent_id,
						'depth'       => count( $ancestors ),
					);

$start ++;
				}

// if repositioned post has been set, and new items are already in the right order, we can stop
				if ( isset( $new_pos[ $post->ID ] ) && $sibling->menu_order >= $start ) {
					$return_data->next = false;
					break;
				}

// set the menu order of the current sibling and increment the menu order
				if ( $sibling->menu_order !== $start ) {
					wp_update_post(
						array(
							'ID'         => $sibling->ID,
							'menu_order' => $start,
						)
					);
				}
				$new_pos[ $sibling->ID ] = $start;
				$start ++;

if ( ! $nextid && $previd === $sibling->ID ) {
					wp_update_post(
						array(
							'ID'          => $post->ID,
							'menu_order'  => $start,
							'post_parent' => $parent_id,
						)
					);

$ancestors            = get_post_ancestors( $post->ID );
					$new_pos[ $post->ID ] = array(
						'menu_order'  => $start,
						'post_parent' => $parent_id,
						'depth'       => count( $ancestors ),
					);
					$start ++;
				}

endforeach;

// max per request
			if ( ! isset( $return_data->next ) && $siblings->max_num_pages > 1 ) {
				$return_data->next = array(
					'id'       => $post->ID,
					'previd'   => $previd,
					'nextid'   => $nextid,
					'start'    => $start,
					'excluded' => array_merge( array_keys( $new_pos ), $excluded ),
				);
			} else {
				$return_data->next = false;
			}

do_action( 'simple_page_ordering_ordered_posts', $post, $new_pos );

if ( ! $return_data->next ) {
				// if the moved post has children, we need to refresh the page (unless we're continuing)
				$children = new WP_Query(
					array(
						'posts_per_page'         => 1,
						'post_type'              => $post->post_type,
						'post_status'            => $post_stati,
						'post_parent'            => $post->ID,
						'fields'                 => 'ids',
						'update_post_term_cache' => false,
						'update_post_meta_cache' => false,
						'ignore_sticky'          => true,
						'no_found_rows'          => true,
					)
				);

if ( $children->have_posts() ) {
					return 'children';
				}
			}

$return_data->new_pos = $new_pos;

return $return_data;
		}

/**
		 * Append a sort by order link to the post actions
		 *
		 * @param array $views An array of available list table views.
		 *
		 * @return array
		 */
		public static function sort_by_order_link( $views ) {
			$class        = ( get_query_var( 'orderby' ) === 'menu_order title' ) ? 'current' : '';
			$query_string = remove_query_arg( array( 'orderby', 'order' ) );
			if ( ! is_post_type_hierarchical( get_post_type() ) ) {
				$query_string = add_query_arg( 'orderby', 'menu_order title', $query_string );
				$query_string = add_query_arg( 'order', 'asc', $query_string );
				$query_string = add_query_arg( 'id', 'simple-page-ordering', $query_string );
			}
			$views['byorder'] = sprintf( '<a href="%s" class="%s">%s</a>', esc_url( $query_string ), $class, __( 'Sort by Order', 'simple-page-ordering' ) );

return $views;
		}

/**
		 * Checks to see if the current user has the capability to "edit others" for a post type
		 *
		 * @param string $post_type Post type name
		 *
		 * @return bool True or false
		 */
		private static function check_edit_others_caps( $post_type ) {
			$post_type_object = get_post_type_object( $post_type );
			$edit_others_cap  = empty( $post_type_object ) ? 'edit_others_' . $post_type . 's' : $post_type_object->cap->edit_others_posts;

return apply_filters( 'simple_page_ordering_edit_rights', current_user_can( $edit_others_cap ), $post_type );
		}

/**
		 * Registers the API endpoint for sorting from the REST endpoint
		 */
		public static function rest_api_init() {
			register_rest_route(
				'simple-page-ordering/v1',
				'page_ordering',
				[
					'methods'             => 'POST',
					'callback'            => array( __CLASS__, 'rest_page_ordering' ),
					'permission_callback' => array( __CLASS__, 'rest_page_ordering_permissions_check' ),
					'args'                => [
						'id'      => [
							'description' => __( 'ID of item we want to sort', 'simple-page-ordering' ),
							'required'    => true,
							'type'        => 'integer',
							'minimum'     => 1,
						],
						'previd'  => [
							'description' => __( 'ID of item we want to be previous to after sorting', 'simple-page-ordering' ),
							'required'    => true,
							'type'        => [ 'boolean', 'integer' ],
						],
						'nextid'  => [
							'description' => __( 'ID of item we want to be next to after sorting', 'simple-page-ordering' ),
							'required'    => true,
							'type'        => [ 'boolean', 'integer' ],
						],
						'start'   => [
							'default'     => 1,
							'description' => __( 'Index we start with when sorting', 'simple-page-ordering' ),
							'required'    => false,
							'type'        => 'integer',
						],
						'exclude' => [
							'default'     => [],
							'description' => __( 'Array of IDs we want to exclude', 'simple-page-ordering' ),
							'required'    => false,
							'type'        => 'array',
							'items'       => [
								'type' => 'integer',
							],
						],
					],
				]
			);
		}

/**
		 * Check if a given request has access to reorder content.
		 *
		 * This check ensures the current user making the request has
		 * proper permissions to edit the item, that the post type
		 * is allowed in REST requests and the post type is sortable.
		 *
		 * @since 2.5.1
		 *
		 * @param WP_REST_Request $request Full data about the request.
		 * @return bool|WP_Error
		 */
		public static function rest_page_ordering_permissions_check( \WP_REST_Request $request ) {
			$post_id = $request->get_param( 'id' );

// Ensure we have a logged in user that can edit the item.
			if ( ! current_user_can( 'edit_post', $post_id ) ) {
				return false;
			}

$post_type     = get_post_type( $post_id );
			$post_type_obj = get_post_type_object( $post_type );

// Ensure the post type is allowed in REST endpoints.
			if ( ! $post_type || empty( $post_type_obj ) || empty( $post_type_obj->show_in_rest ) ) {
				return false;
			}

// Ensure this post type is sortable.
			if ( ! self::is_post_type_sortable( $post_type ) ) {
				return new WP_Error( 'not_enabled', esc_html__( 'This post type is not sortable.', 'simple-page-ordering' ) );
			}

return true;
		}

/**
		 * Handle REST page sorting
		 *
		 * @param WP_REST_Request $request The REST request object.
		 */
		public static function rest_page_ordering( \WP_REST_Request $request ) {
			$post_id  = empty( $request->get_param( 'id' ) ) ? false : (int) $request->get_param( 'id' );
			$previd   = empty( $request->get_param( 'previd' ) ) ? false : (int) $request->get_param( 'previd' );
			$nextid   = empty( $request->get_param( 'nextid' ) ) ? false : (int) $request->get_param( 'nextid' );
			$start    = empty( $request->get_param( 'start' ) ) ? 1 : (int) $request->get_param( 'start' );
			$excluded = empty( $request->get_param( 'excluded' ) ) ? array( $request->get_param( 'id' ) ) : array_filter( (array) json_decode( $request->get_param( 'excluded' ) ), 'intval' );

// Check and make sure we have what we need.
			if ( false === $post_id || ( false === $previd && false === $nextid ) ) {
				return new WP_Error( 'invalid', __( 'Missing mandatory parameters.', 'simple-page-ordering' ) );
			}

$page_ordering = self::page_ordering( $post_id, $previd, $nextid, $start, $excluded );

if ( is_wp_error( $page_ordering ) ) {
				return $page_ordering;
			}

return new WP_REST_Response(
				array(
					'status'        => 200,
					'response'      => 'success',
					'body_response' => $page_ordering,
				)
			);
		}
	}

Simple_Page_Ordering::get_instance();

endif;