Hanson.xyz Dev
901 lines
28 KiB
PHP
Executable File
901 lines
28 KiB
PHP
Executable File
<?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.4' );
|
|
|
|
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;
|