Skip to:
Content

BuddyPress.org

Ticket #6221: 6221.01.patch

File 6221.01.patch, 11.8 KB (added by r-a-y, 6 years ago)
  • src/bp-messages/bp-messages-cache.php

     
    4646add_action( 'messages_screen_inbox',   'bp_core_clear_cache' );
    4747
    4848/**
    49  * Clear unread count cache for each recipient after a message is sent.
     49 * Clear message cache after a message is saved.
    5050 *
    5151 * @since BuddyPress (2.0.0)
    5252 *
    5353 * @param BP_Messages_Message $message
    5454 */
    55 function bp_messages_clear_unread_count_cache_on_message_save( BP_Messages_Message $message ) {
     55function bp_messages_clear_on_message_save( BP_Messages_Message $message ) {
     56        // Delete thread cache
     57        wp_cache_delete( "thread_{$message->thread_id}", 'bp_messages' );
     58
     59        // Delete unread count for each recipient
    5660        foreach ( (array) $message->recipients as $recipient ) {
    5761                wp_cache_delete( $recipient->user_id, 'bp_messages_unread_count' );
    5862        }
     63
     64        // Delete thread recipient cache
     65        wp_cache_delete( 'thread_recipients_' . $message->thread_id, 'bp_messages' );
    5966}
    60 add_action( 'messages_message_after_save', 'bp_messages_clear_unread_count_cache_on_message_save' );
     67add_action( 'messages_message_after_save', 'bp_messages_clear_on_message_save' );
    6168
    6269/**
    63  * Clear unread count cache for the logged-in user after a message is deleted.
     70 * Clear message cache after a message thread is deleted.
    6471 *
    6572 * @since BuddyPress (2.0.0)
    6673 *
    6774 * @param int|array $thread_ids If single thread, the thread ID. Otherwise, an
    6875 *  array of thread IDs
    6976 */
    70 function bp_messages_clear_unread_count_cache_on_message_delete( $thread_ids ) {
     77function bp_messages_clear_cache_on_message_delete( $thread_ids ) {
     78        // Delete thread and thread recipient cache
     79        foreach( (array) $thread_ids as $thread_id ) {
     80                wp_cache_delete( "thread_{$thread_id}", 'bp_messages' );
     81                wp_cache_delete( "thread_recipients_{$thread_id}", 'bp_messages' );
     82        }
     83
     84        // Delete unread count for logged-in user
    7185        wp_cache_delete( bp_loggedin_user_id(), 'bp_messages_unread_count' );
    7286}
    73 add_action( 'messages_before_delete_thread', 'bp_messages_clear_unread_count_cache_on_message_delete' );
     87add_action( 'messages_before_delete_thread', 'bp_messages_clear_cache_on_message_delete' );
    7488
    7589/**
    7690 * Invalidate cache for notices.
     
    8498}
    8599add_action( 'messages_notice_after_save',    'bp_notices_clear_cache' );
    86100add_action( 'messages_notice_before_delete', 'bp_notices_clear_cache' );
    87 
    88 /**
    89  * Invalidate thread recipient cache on message update.
    90  *
    91  * @since BuddyPress (2.3.0)
    92  *
    93  * @param BP_Messages_Message $message Message object.
    94  */
    95 function bp_messages_clear_message_thread_recipient_cache_on_message_sent( BP_Messages_Message $message ) {
    96         wp_cache_delete( 'thread_recipients_' . $message->thread_id, 'bp_messages' );
    97 }
    98 add_action( 'messages_message_sent', 'bp_messages_clear_message_thread_recipient_cache_on_message_sent' );
    99 
    100 /**
    101  * Invalidate thread recipient cache on thread deletion.
    102  *
    103  * @since BuddyPress (2.3.0)
    104  *
    105  * @param int|array $thread_ids IDs of deleted threads.
    106  */
    107 function bp_messages_clear_message_thread_recipient_cache_on_thread_delete( $thread_ids ) {
    108         foreach ( (array) $thread_ids as $thread_id ) {
    109                 wp_cache_delete( 'thread_recipients_' . $thread_id, 'bp_messages' );
    110         }
    111 }
    112 add_action( 'messages_delete_thread', 'bp_messages_clear_message_thread_recipient_cache_on_thread_delete' );
  • src/bp-messages/classes/class-bp_messages-thread.php

     
    147147                $this->messages_order = $order;
    148148                $this->thread_id      = $thread_id;
    149149
    150                 $bp = buddypress();
     150                // get messages for thread
     151                $this->messages = self::get_messages( $thread_id );
    151152
    152                 if ( !$this->messages = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM {$bp->messages->table_name_messages} WHERE thread_id = %d ORDER BY date_sent " . $order, $this->thread_id ) ) ) {
     153                if ( empty( $this->messages ) || is_wp_error( $this->messages ) ) {
    153154                        return false;
    154155                }
    155156
     157                // flip if order is DESC
     158                if ( 'DESC' === $order ) {
     159                        $this->messages = array_reverse( $this->messages );
     160                }
     161
    156162                foreach ( (array) $this->messages as $key => $message ) {
    157163                        $this->sender_ids[$message->sender_id] = $message->sender_id;
    158164                }
     
    207213         *
    208214         * @since BuddyPress (1.0.0)
    209215         *
     216         * @param int $thread_id The thread ID
    210217         * @return array
    211218         */
    212         public function get_recipients() {
     219        public function get_recipients( $thread_id = 0 ) {
    213220                global $wpdb;
    214221
    215                 $recipients = wp_cache_get( 'thread_recipients_' . $this->thread_id, 'bp_messages' );
     222                if ( empty( $thread_id ) ) {
     223                        $thread_id = $this->thread_id;
     224                }
     225
     226                $recipients = wp_cache_get( 'thread_recipients_' . $thread_id, 'bp_messages' );
    216227                if ( false === $recipients ) {
    217228                        $bp = buddypress();
    218229
    219230                        $recipients = array();
    220                         $results    = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM {$bp->messages->table_name_recipients} WHERE thread_id = %d", $this->thread_id ) );
     231                        $results    = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM {$bp->messages->table_name_recipients} WHERE thread_id = %d", $thread_id ) );
    221232
    222233                        foreach ( (array) $results as $recipient ) {
    223234                                $recipients[ $recipient->user_id ] = $recipient;
    224235                        }
    225236
    226                         wp_cache_set( 'thread_recipients_' . $this->thread_id, $recipients, 'bp_messages' );
     237                        wp_cache_set( 'thread_recipients_' . $thread_id, $recipients, 'bp_messages' );
    227238                }
    228239
    229240                /**
     
    234245                 * @param array $recipients Array of recipient objects.
    235246                 * @param int   $thread_id  ID of the current thread.
    236247                 */
    237                 return apply_filters( 'bp_messages_thread_get_recipients', $recipients, $this->thread_id );
     248                return apply_filters( 'bp_messages_thread_get_recipients', $recipients, $thread_id );
    238249        }
    239250
    240251        /** Static Functions ******************************************************/
    241252
    242253        /**
     254         * Get all messages associated with a thread.
     255         *
     256         * @since BuddyPress (2.3.0)
     257         *
     258         * @param int $thread_id The message thread ID
     259         * @return array
     260         */
     261        public static function get_messages( $thread_id = 0 ) {
     262                $messages = wp_cache_get( "thread_{$thread_id}", 'bp_messages' );
     263
     264                if ( false === $messages ) {
     265                        global $wpdb;
     266
     267                        $bp = buddypress();
     268
     269                        // always sort by ASC by default
     270                        $messages = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM {$bp->messages->table_name_messages} WHERE thread_id = %d ORDER BY date_sent ASC", $thread_id ) );
     271
     272                        wp_cache_set( "thread_{$thread_id}", (array) $messages, 'bp_messages' );
     273                }
     274
     275                return $messages;
     276        }
     277
     278        /**
     279         * Static method to get message recipients by thread ID.
     280         *
     281         * @since BuddyPress (2.3.0)
     282         *
     283         * @param  int $thread_id The thread ID
     284         * @return array
     285         */
     286        public static function get_recipients_for_thread( $thread_id = 0 ) {
     287                $thread = new self( false );
     288                return $thread->get_recipients( $thread_id );
     289        }
     290
     291        /**
    243292         * Mark messages in a thread as deleted or delete all messages in a thread.
    244293         *
    245294         * Note: All messages in a thread are deleted once every recipient in a thread
     
    644693         *
    645694         * @param int $thread_id The message thread ID.
    646695         * @param int $user_id The user ID.
    647          * @return int The message ID on success.
     696         * @return int|null The recorded recipient ID on success, null on failure
    648697         */
    649698        public static function check_access( $thread_id, $user_id = 0 ) {
    650                 global $wpdb;
    651 
    652                 if ( empty( $user_id ) )
     699                if ( empty( $user_id ) ) {
    653700                        $user_id = bp_loggedin_user_id();
     701                }
    654702
    655                 $bp = buddypress();
     703                $recipients = self::get_recipients_for_thread( $thread_id );
    656704
    657                 return $wpdb->get_var( $wpdb->prepare( "SELECT id FROM {$bp->messages->table_name_recipients} WHERE thread_id = %d AND is_deleted = 0 AND user_id = %d", $thread_id, $user_id ) );
     705                if ( isset( $recipients[$user_id] ) && 0 == $recipients[$user_id]->is_deleted ) {
     706                        return $recipients[$user_id]->id;
     707                } else {
     708                        return null;
     709                }
    658710        }
    659711
    660712        /**
     
    663715         * @since BuddyPress (1.0.0)
    664716         *
    665717         * @param int $thread_id The message thread ID.
    666          * @return int The message thread ID on success.
     718         * @return int|null The message thread ID on success, null on failure
    667719         */
    668720        public static function is_valid( $thread_id = 0 ) {
    669                 global $wpdb;
    670 
    671721                // Bail if no thread ID is passed
    672722                if ( empty( $thread_id ) ) {
    673723                        return false;
    674724                }
    675725
    676                 $bp = buddypress();
     726                $thread = self::get_messages( $thread_id );
    677727
    678                 return $wpdb->get_var( $wpdb->prepare( "SELECT thread_id FROM {$bp->messages->table_name_messages} WHERE thread_id = %d LIMIT 1", $thread_id ) );
     728                if ( ! empty( $thread ) ) {
     729                        return $thread_id;
     730                } else {
     731                        return null;
     732                }
    679733        }
    680734
    681735        /**
  • tests/phpunit/testcases/messages/class.bp-messages-thread.php

     
    44 * @group BP_Messages_Thread
    55 */
    66class BP_Tests_BP_Messages_Thread extends BP_UnitTestCase {
     7
     8        /**
     9         * @group cache
     10         */
     11        public function test_construct_cache() {
     12                $u1 = $this->factory->user->create();
     13                $u2 = $this->factory->user->create();
     14
     15                $t1 = $this->factory->message->create( array(
     16                        'sender_id' => $u1,
     17                        'recipients' => array( $u2 ),
     18                        'subject' => 'Foo',
     19                ) );
     20
     21                // prime cache
     22                new BP_Messages_Thread( $t1 );
     23
     24                // Cache should exist
     25                $this->assertThat(
     26                        wp_cache_get( "thread_{$t1}", 'bp_messages' ),
     27                        $this->logicalNot( $this->equalTo( false ) ),
     28                        'Message thread cache should exist.'
     29                );
     30        }
     31
     32        /**
     33         * @group order
     34         */
     35        public function test_construct_order_desc() {
     36                $u1 = $this->factory->user->create();
     37                $u2 = $this->factory->user->create();
     38
     39                // create thread
     40                $t1 = $this->factory->message->create( array(
     41                        'sender_id' => $u1,
     42                        'recipients' => array( $u2 ),
     43                        'subject' => 'Foo',
     44                ) );
     45                // save message ID
     46                $thread = new BP_Messages_Thread( $t1 );
     47                $m1 = wp_list_pluck( $thread->messages, 'id' );
     48                $m1 = array_pop( $m1 );
     49
     50                // create reply
     51                $t2 = $this->factory->message->create( array(
     52                        'thread_id' => $t1,
     53                        'sender_id' => $u1,
     54                        'recipients' => array( $u2 ),
     55                        'content' => 'Bar'
     56                ) );
     57                // save message ID
     58                $thread = new BP_Messages_Thread( $t1 );
     59                $m2 = wp_list_pluck( $thread->messages, 'id' );
     60                $m2 = array_pop( $m2 );
     61
     62                // now get thread by DESC
     63                $thread = new BP_Messages_Thread( $t1, 'DESC' );
     64
     65                // assert!
     66                $this->assertEquals(
     67                        array( $m2, $m1 ),
     68                        wp_list_pluck( $thread->messages, 'id' )
     69                );
     70        }
     71
    772        /**
    873         * @group get_current_threads_for_user
    974         */
     
    286351
    287352                $this->set_current_user( $current_user );
    288353        }
     354
     355        /**
     356         * @group check_access
     357         */
     358        public function test_check_access_valid_thread() {
     359                $u1 = $this->factory->user->create();
     360                $u2 = $this->factory->user->create();
     361
     362                $t1 = $this->factory->message->create( array(
     363                        'sender_id' => $u1,
     364                        'recipients' => array( $u2 ),
     365                        'subject' => 'Foo',
     366                ) );
     367
     368                // save recipient ID
     369                $thread = new BP_Messages_Thread( $t1 );
     370                $r1 = wp_list_pluck( $thread->recipients, 'id' );
     371                $r1 = array_pop( $r1 );
     372
     373                $this->assertEquals( $r1, BP_Messages_Thread::check_access( $t1, $u1 ) );
     374        }
     375
     376        /**
     377         * @group check_access
     378         */
     379        public function test_check_access_invalid_thread() {
     380                $this->assertEquals( null, BP_Messages_Thread::check_access( 999, 1 ) );
     381        }
     382
     383        /**
     384         * @group is_valid
     385         */
     386        public function test_is_valid_valid_thread() {
     387                $u1 = $this->factory->user->create();
     388                $u2 = $this->factory->user->create();
     389
     390                $t1 = $this->factory->message->create( array(
     391                        'sender_id' => $u1,
     392                        'recipients' => array( $u2 ),
     393                        'subject' => 'Foo',
     394                ) );
     395
     396                $this->assertEquals( $t1, BP_Messages_Thread::is_valid( $t1 ) );
     397        }
     398
     399        /**
     400         * @group is_valid
     401         */
     402        public function test_is_valid_invalid_thread() {
     403                $this->assertEquals( null, BP_Messages_Thread::is_valid( 999 ) );
     404        }
    289405}