Ticket #32202: edit_lock.patch

wp-admin/includes/admin.php

@@ -33 +33 @@
 /** WordPress Import Administration API */
 require_once(ABSPATH . 'wp-admin/includes/import.php');
 
+/** WordPress Edit Lock Administration API */
+require_once(ABSPATH . 'wp-admin/includes/edit-lock.php');
+
 /** WordPress Misc Administration API */
 require_once(ABSPATH . 'wp-admin/includes/misc.php');
 

wp-admin/includes/ajax-actions.php

@@ -2113 +2113 @@
  * @since 3.1.0
  */
 function wp_ajax_wp_remove_post_lock() {
-        if ( empty( $_POST['post_ID'] ) || empty( $_POST['active_post_lock'] ) )
+        if ( empty( $_POST['post_ID'] ) )
                 wp_die( 0 );
         $post_id = (int) $_POST['post_ID'];
         if ( ! $post = get_post( $post_id ) )
@@ -2124 +2124 @@
         if ( ! current_user_can( 'edit_post', $post_id ) )
                 wp_die( -1 );
 
-        $active_lock = array_map( 'absint', explode( ':', $_POST['active_post_lock'] ) );
+        $active_lock = wp_get_edit_lock('post', $post_id);
         if ( $active_lock[1] != get_current_user_id() )
                 wp_die( 0 );
 
@@ -2136 +2136 @@
          * @param int $interval The interval in seconds the post lock duration
          *                      should last, plus 5 seconds. Default 150.
          */
-        $new_lock = ( time() - apply_filters( 'wp_check_post_lock_window', 150 ) + 5 ) . ':' . $active_lock[1];
-        update_post_meta( $post_id, '_edit_lock', $new_lock, implode( ':', $active_lock ) );
+        $time_window = apply_filters( 'wp_check_post_lock_window', 150 );
+        /** This filter is documented in wp-admin/includes/edit-lock.php */
+        $time_window = apply_filters( 'wp_edit_' . 'post' . '_lock_window', $time_window );
+        // Set lock time in the past, add 5 second buffer in case user changes their mind.
+        $time = time() - $time_window + 5;
+        wp_set_edit_lock('post', $post_id, $time, $active_lock[1]);
         wp_die( 1 );
 }
 

wp-admin/includes/edit-lock.php

@@ +1 @@
+<?php
+/**
+ * Functions for edit locking functionality
+ *
+ * @package WordPress\Administration
+ */
+
+/**
+ * Get an edit lock for an object if it exists.
+ * 
+ * @param string $type Type of object to check for editing (e.g. post). Type 'site' will be treated as a multisite lock.
+ * @param int|string $id Unique identifier of the object to check for editing (e.g. post_id).
+ * @return bool|array False: not locked. Array: Lock information consisting of time and user_id.
+ */
+function wp_get_edit_lock( $type, $id ) {
+        if ( in_array( $type, array( 'comment', 'post', 'user' ), true ) ) {
+                // Locks stored in *meta
+
+                switch ( $type ) {
+                        case 'comment':
+                                if ( ! $comment = get_comment( $id ) )
+                                        return false;
+
+                                $object_id = $comment->comment_ID;
+                                break;
+                        case 'post':
+                                if ( ! $post = get_post( $id ) )
+                                        return false;
+
+                                $object_id = $post->ID;
+                                break;
+                        case 'user':
+                                if ( ! $user = get_user_by( 'id', $id ) )
+                                        return false;
+
+                                $object_id = $user->ID;
+                                break;
+                }
+
+                if ( ! $lock = get_metadata( $type, $object_id, '_edit_lock', true ) )
+                        return false;
+
+        } else {
+                // Locks stored in options
+
+                $locks = _wp_edit_lock_get_locks( $type );
+
+                if ( ! isset( $locks[$id] ) )
+                        return false;
+
+                $lock = $locks[$id];
+        }
+
+        $lock = wp_read_edit_lock( $lock );
+        $time = $lock[0];
+        if ( 'post' === $type ) {
+                // Posts have a special fallback for user
+                $user_id = is_null( $lock[1] ) ? get_post_meta( $post->ID, '_edit_last', true ) : $lock[1];
+        } else {
+                $user_id = is_null( $lock[1] ) ? get_current_user_id() : $lock[1];
+        }
+
+        return array( $time, $user_id );
+}
+
+/**
+ * Check to see if the object is currently being edited by another user.
+ * 
+ * @param string $type Type of object to check for editing (e.g. post). Type 'site' will be treated as a multisite lock.
+ * @param int|string $id Unique identifier of the object to check for editing (e.g. post_id).
+ * @return bool|int False: not locked or locked by current user. Int: user ID of the user with lock.
+ */
+function wp_check_edit_lock( $type, $id ) {
+
+        /**
+         * Filter allow edit lock. Short circuits function.
+         *
+         * @param bool $allow Allow edit lock. Default true.
+         * @param string $type Type of object to check for editing (e.g. post).
+         * @param int|string $id Unique identifier of the object to check for editing (e.g. post_id).
+         */
+        $allow = apply_filters( 'allow_edit_lock', true, $type, $id );
+
+        if ( ! $allow )
+                return false;
+
+        $lock = wp_get_edit_lock( $type, $id );
+
+        if ( ! $lock )
+                return false;
+
+        $time = $lock[0];
+        $user_id = $lock[1];
+
+        if ( 'post' === $type ) {
+                /** This filter is documented in wp-admin/includes/ajax-actions.php */
+                $time_window = apply_filters( 'wp_check_post_lock_window', 150 );
+        } else {
+                $time_window = 150; // Default value
+        }
+
+        /**
+         * Filter the post lock window duration.
+         *
+         * @param int $interval The interval in seconds of the edit lock duration. Default 150.
+         */
+        $time_window = apply_filters( 'wp_edit_' . $type . '_lock_window', $time_window );
+
+        if ( $time && $time > time() - $time_window && $user_id != get_current_user_id() )
+                return $user_id;
+
+        return false;
+}
+
+/**
+ * Mark the object as currently being edited by the current user.
+ *
+ * @param string $type Type of object to be edited (e.g. post). Type 'site' will be treated as a multisite lock.
+ * @param int|string $id Unique identifier of the object to edit (e.g. post_id).
+ * @param int $time Optional. Unix timestamp of the lock. Default time().
+ * @param int $user_id Optional. User ID to give the lock. Default get_current_user_id().
+ * @return bool|string False: if there is no current user. String: value of the edit lock.
+ */
+function wp_set_edit_lock( $type, $id, $time = null, $user_id = null ) {
+        $lock = wp_create_edit_lock( $time, $user_id );
+
+        if ( ! $lock )
+                return false;
+
+        if ( in_array( $type, array( 'comment', 'post', 'user' ), true ) ) {
+                // Locks stored in *meta
+
+                switch ( $type ) {
+                        case 'comment':
+                                if ( ! $comment = get_comment( $id ) )
+                                        return false;
+
+                                $object_id = $comment->comment_ID;
+                                break;
+                        case 'post':
+                                if ( ! $post = get_post( $id ) )
+                                        return false;
+
+                                $object_id = $post->ID;
+                                break;
+                        case 'user':
+                                if ( ! $user = get_user_by( 'id', $id ) )
+                                        return false;
+
+                                $object_id = $user->ID;
+                                break;
+                }
+
+        } else {
+                // Locks stored in options
+
+                $locks = _wp_edit_lock_get_locks( $type );
+
+                /** This filter is documented in wp-admin/includes/edit-lock.php */
+                $time_window = apply_filters( 'wp_edit_' . $type . '_lock_window', 150 );
+
+                // Remove expired locks
+                foreach ( $locks as $_id => $_lock ) {
+                        $_lock = wp_read_edit_lock( $_lock );
+                        $time = $_lock[0];
+
+                        if ( ! $time || $time <= time() - $time_window )
+                                unset( $locks[$_id] );
+                }
+
+        }
+
+        // Update locks
+        if ( in_array( $type, array( 'comment', 'post', 'user' ), true ) ) {
+                update_metadata( $type, $object_id, '_edit_lock', $lock );
+        } else {
+                $locks[$id] = $lock;
+                _wp_edit_lock_update_locks( $type, $locks );
+        }
+
+        return wp_read_edit_lock( $lock );
+}
+
+/**
+ * Read lock information from an edit lock string.
+ * 
+ * @param string $lock Edit lock string consisting of time and user_id.
+ * @return array Lock information consisting of time and user_id. Note: user_id may be null.
+ */
+function wp_read_edit_lock( $lock ) {
+        $lock = explode( ':', $lock, 2 );
+
+        $time = absint( $lock[0] );
+        $user_id = empty( $lock[1] ) ? null : absint( $lock[1] );
+
+        return array( $time, $user_id );
+}
+
+/**
+ * Pack lock information into an edit lock string.
+ *
+ * @param int $time Optional. Unix timestamp of the lock. Default time().
+ * @param int $user_id Optional. User ID to give the lock. Default get_current_user_id().
+ * @return bool|string False: if there is no current user. String: Edit lock string consisting of time and user_id.
+ */
+function wp_create_edit_lock( $time = null, $user_id = null ) {
+        if ( ! is_numeric( $time ) || ! $time = absint( $time ) ) {
+                $time = time();
+        }
+
+        if ( ! $user_id = absint( $user_id ) ) {
+                if ( 0 == ($user_id = get_current_user_id()) )
+                        return false;
+        }
+
+        return $time . ':' . $user_id;
+}
+ 
+/**
+ * Edit lock name for the options table.
+ *
+ * @access private
+ * 
+ * @param string $type Type of edit lock.
+ * @return string Edit lock option name.
+ */
+function _wp_edit_lock_option_name( $type ) {
+        return '_edit_' . trim($type) . '_lock';
+}
+
+/**
+ * Get all locks from options that are associated with a type.
+ *
+ * @access private
+ * 
+ * @param string $type Type of edit lock.
+ * @return array Existing locks (may be empty).
+ */
+function _wp_edit_lock_get_locks( $type ) {
+        $edit_lock_name = _wp_edit_lock_option_name( $type );
+
+        if ( 'site' === $type && is_multisite() ) {
+                if ( ! $locks = get_site_option( $edit_lock_name ) )
+                        return array();
+        } else {
+                if ( ! $locks = get_option( $edit_lock_name ) )
+                        return array();
+        }
+
+        if ( ! is_array($locks) )
+                return array();
+
+        return $locks;
+}
+
+/**
+ * Updates all locks in options that are associated with a type.
+ * 
+ * @access private
+ * 
+ * @param string $type Type of edit lock.
+ * @param array $locks Existing locks.
+ * @return bool False if value was not updated and true if value was updated.
+ */
+function _wp_edit_lock_update_locks( $type, $locks ) {
+        $edit_lock_name = _wp_edit_lock_option_name( $type );
+
+        if ( $type === 'site' && is_multisite() ) {
+                return update_site_option( $edit_lock_name, $locks );
+        } else {
+                return update_option( $edit_lock_name, $locks, 'no' );
+        }
+}
+ No newline at end of file

wp-admin/includes/post.php

@@ -1386 +1386 @@
  * @return integer False: not locked or locked by current user. Int: user ID of user with lock.
  */
 function wp_check_post_lock( $post_id ) {
-        if ( !$post = get_post( $post_id ) )
-                return false;
-
-        if ( !$lock = get_post_meta( $post->ID, '_edit_lock', true ) )
-                return false;
-
-        $lock = explode( ':', $lock );
-        $time = $lock[0];
-        $user = isset( $lock[1] ) ? $lock[1] : get_post_meta( $post->ID, '_edit_last', true );
-
-        /** This filter is documented in wp-admin/includes/ajax-actions.php */
-        $time_window = apply_filters( 'wp_check_post_lock_window', 150 );
-
-        if ( $time && $time > time() - $time_window && $user != get_current_user_id() )
-                return $user;
-        return false;
+        return wp_check_edit_lock( 'post', $post_id );
 }
 
 /**
@@ -1414 +1399 @@
  *      an array of the lock time and the user ID.
  */
 function wp_set_post_lock( $post_id ) {
-        if ( !$post = get_post( $post_id ) )
-                return false;
-        if ( 0 == ($user_id = get_current_user_id()) )
-                return false;
-
-        $now = time();
-        $lock = "$now:$user_id";
-
-        update_post_meta( $post->ID, '_edit_lock', $lock );
-        return array( $now, $user_id );
+        return wp_set_edit_lock( 'post', $post_id );
 }
 
 /**

wp-admin/js/post.js

@@ -391 +391 @@
                         data: {
                                 action: 'wp-remove-post-lock',
                                 _wpnonce: $('#_wpnonce').val(),
-                                post_ID: $('#post_ID').val(),
-                                active_post_lock: $('#active_post_lock').val()
+                                post_ID: $('#post_ID').val()
                         }
                 });
         });