Ticket #6210: 6210.bp_get_user_groups.diff

src/bp-core/bp-core-cache.php

@@ -169 +169 @@
         return $uncached;
 }
 
+/**
+ * Determine which items from a list do not have cached values,
+ * when the cache ID is not an integer.
+ *
+ * @since 5.0.0
+ *
+ * @param array  $item_keys   Key list.
+ * @param string $cache_group The cache group to check against.
+ * @return array
+ */
+function bp_get_non_cached_keys( $item_keys, $cache_group ) {
+        $uncached = array();
+
+        foreach ( $item_keys as $item_key ) {
+                if ( false === wp_cache_get( $item_key, $cache_group ) ) {
+                        $uncached[] = $item_key;
+                }
+        }
+
+        return $uncached;
+}
+
 /**
  * Update the metadata cache for the specified objects.
  *

src/bp-groups/bp-groups-cache.php

@@ -254 +254 @@
 add_action( 'groups_member_before_save', 'bp_groups_clear_user_group_cache_on_membership_save' );
 add_action( 'groups_member_before_remove', 'bp_groups_clear_user_group_cache_on_membership_save' );
 
+/**
+ * Clear caches on invitation.
+ *
+ * @since 5.0.0
+ *
+ * @param array $args Array of parsed arguments for the group invite.
+ */
+function bp_groups_clear_user_group_cache_on_invitation( $args ) {
+        wp_cache_delete( $args['user_id'], 'bp_groups_memberships_for_user' );
+        wp_cache_delete( $args['group_id'], 'bp_groups_memberships' );
+}
+add_action( 'groups_invite_user', 'bp_groups_clear_user_group_cache_on_invitation' );
+
+/**
+ * Clear caches on uninvitation.
+ *
+ * @since 5.0.0
+ *
+ * @param int $group_id    ID of the group being uninvited from.
+ * @param int $user_id     ID of the user being uninvited.
+ */
+function bp_groups_clear_user_group_cache_on_invitation_uninvite( $group_id, $user_id ) {
+        wp_cache_delete( $user_id, 'bp_groups_memberships_for_user' );
+        wp_cache_delete( $group_id, 'bp_groups_memberships' );
+}
+add_action( 'groups_uninvite_user', 'bp_groups_clear_user_group_cache_on_invitation_uninvite', 10, 2 );
+
+/**
+ * Clear caches on acceptance, rejection or deletion of invitation.
+ *
+ * @since 5.0.0
+ *
+ * @param int $group_id    ID of the group being uninvited from.
+ * @param int $user_id     ID of the user being uninvited.
+ */
+function bp_groups_clear_user_group_cache_on_invitation_change( $user_id, $group_id ) {
+        wp_cache_delete( $user_id, 'bp_groups_memberships_for_user' );
+        wp_cache_delete( $group_id, 'bp_groups_memberships' );
+}
+add_action( 'groups_accept_invite', 'bp_groups_clear_user_group_cache_on_invitation_change', 10, 2 );
+add_action( 'groups_reject_invite', 'bp_groups_clear_user_group_cache_on_invitation_change', 10, 2 );
+add_action( 'groups_delete_invite', 'bp_groups_clear_user_group_cache_on_invitation_change', 10, 2 );
+
+/**
+ * Clear caches on sending of invitations.
+ *
+ * @since 5.0.0
+ *
+ * @param int   $group_id      ID of the group who's being invited to.
+ * @param array $invited_users Array of users being invited to the group.
+ */
+function bp_groups_clear_user_group_cache_on_invitation_send( $group_id, $invited_users ) {
+        foreach ( $invited_users as $invited_user_id ) {
+                wp_cache_delete( $invited_user_id, 'bp_groups_memberships_for_user' );
+        }
+        wp_cache_delete( $group_id, 'bp_groups_memberships' );
+}
+add_action( 'groups_send_invites', 'bp_groups_clear_user_group_cache_on_invitation_send', 10, 2 );
+
+/**
+ * Clear caches on sending of membership request.
+ *
+ * @since 5.0.0
+ *
+ * @param int   $requesting_user_id  ID of the user requesting membership.
+ * @param array $admins              Array of group admins.
+ * @param int   $group_id            ID of the group being requested to
+ */
+function bp_groups_clear_user_group_cache_on_membership_request( $requesting_user_id, $admins, $group_id ) {
+        wp_cache_delete( $requesting_user_id, 'bp_groups_memberships_for_user' );
+        wp_cache_delete( $group_id, 'bp_groups_memberships' );
+}
+add_action( 'groups_membership_requested', 'bp_groups_clear_user_group_cache_on_membership_request', 10, 3 );
+
 /**
  * Clear group memberships cache on miscellaneous actions not covered by the 'after_save' hook.
  *
@@ -269 +343 @@
         wp_cache_delete( $membership->id, 'bp_groups_memberships' );
 }
 add_action( 'bp_groups_member_before_delete', 'bp_groups_clear_user_group_cache_on_other_events', 10, 2 );
-add_action( 'bp_groups_member_before_delete_invite', 'bp_groups_clear_user_group_cache_on_other_events', 10, 2 );
-add_action( 'groups_accept_invite', 'bp_groups_clear_user_group_cache_on_other_events', 10, 2 );
 
 /**
  * Reset cache incrementor for the Groups component.

src/bp-groups/bp-groups-functions.php

@@ -948 +948 @@
         ), 'get_user_groups' );
 
         $user_id = intval( $user_id );
+        $invites_prefix = BP_Invitation_Manager::get_table_name() . '_';
 
-        // @TODO-6210: This is tied to the groups membership table. How to include invites/requests from a separate table?
         $membership_ids = wp_cache_get( $user_id, 'bp_groups_memberships_for_user' );
         if ( false === $membership_ids ) {
                 $membership_ids = BP_Groups_Member::get_membership_ids_for_user( $user_id );
+                // Fetch invitations and requests.
+                $invitation_ids = groups_get_invites( array(
+                        'user_id'     => $user_id,
+                        'invite_sent' => 'all',
+                        'fields'      => 'ids',
+                        'type'        => 'all'
+                ) );
+                // Prepend invitation table name.
+                array_walk( $invitation_ids, function ( &$value, $key, $invites_prefix ) { $value = $invites_prefix . $value; }, $invites_prefix );
+                $membership_ids = array_merge( $membership_ids, $invitation_ids );
                 wp_cache_set( $user_id, $membership_ids, 'bp_groups_memberships_for_user' );
         }
 
         // Prime the membership cache.
-        $uncached_membership_ids = bp_get_non_cached_ids( $membership_ids, 'bp_groups_memberships' );
+        $uncached_membership_ids = bp_get_non_cached_keys( $membership_ids, 'bp_groups_memberships' );
         if ( ! empty( $uncached_membership_ids ) ) {
-                $uncached_memberships = BP_Groups_Member::get_memberships_by_id( $uncached_membership_ids );
+        // Sort the uncached items into regular memberships and invitations.
+                $uncached_invitation_ids = array();
+                foreach ( $uncached_membership_ids as $key => $membership_id ) {
+                        if ( strpos( $membership_id, $invites_prefix ) !== false) {
+                                $uncached_invitation_ids[] = substr( $membership_id, strlen( $invites_prefix ) );
+                                unset( $uncached_membership_ids[$key] );
+                        }
+                }
 
-                foreach ( $uncached_memberships as $uncached_membership ) {
-                        wp_cache_set( $uncached_membership->id, $uncached_membership, 'bp_groups_memberships' );
+                // Set memberships.
+                if ( $uncached_membership_ids ) {
+                        $uncached_memberships = BP_Groups_Member::get_memberships_by_id( $uncached_membership_ids );
+
+                        foreach ( $uncached_memberships as $uncached_membership ) {
+                                wp_cache_set( $uncached_membership->id, $uncached_membership, 'bp_groups_memberships' );
+                        }
                 }
+
+                // Set invitations/requests.
+                if ( $uncached_invitation_ids ) {
+                        $uncached_invitations = groups_get_invites( array(
+                                'ids'         => $uncached_invitation_ids,
+                                'invite_sent' => 'all',
+                                'type'        => 'all'
+                        ) );
+                        foreach ( $uncached_invitations as $uncached_invitation ) {
+                                // Reshape the result as a membership db entry.
+                                $invitation = new StdClass;
+                                $invitation->id            = $uncached_invitation->id;
+                                $invitation->group_id      = $uncached_invitation->item_id;
+                                $invitation->user_id       = $uncached_invitation->user_id;
+                                $invitation->inviter_id    = $uncached_invitation->inviter_id;
+                                $invitation->is_admin      = false;
+                                $invitation->is_mod            = false;
+                                $invitation->user_title    = '';
+                                $invitation->date_modified = $uncached_invitation->date_modified;
+                                $invitation->comments      = $uncached_invitation->content;
+                                $invitation->is_confirmed  = false;
+                                $invitation->is_banned     = false;
+                                $invitation->invite_sent   = $uncached_invitation->invite_sent;
+                                wp_cache_set( $invites_prefix . $invitation->id, $invitation, 'bp_groups_memberships' );
+                        }
+                }
+
         }
 
         // Assemble filter array for use in `wp_list_filter()`.

src/bp-groups/classes/class-bp-groups-invitation-manager.php

@@ -65 +65 @@
          *
          * @since 2.7.0
          *
-         * @param int $id The ID of the invitation to mark as sent.
+         * @param string $type Are we accepting an invitation or request?
+         * @param array  $r    Parameters that describe the invitation being accepted.
          * @return bool True on success, false on failure.
          */
         public function run_acceptance_action( $type = 'invite', $r  ) {
@@ -88 +89 @@
                         return false;
                 }
 
+                if ( 'request' === $type ) {
+                        /**
+                         * Fires after a group membership request has been accepted.
+                         *
+                         * @since 1.0.0
+                         *
+                         * @param int  $user_id  ID of the user who accepted membership.
+                         * @param int  $group_id ID of the group that was accepted membership to.
+                         * @param bool $value    If membership was accepted.
+                         */
+                        do_action( 'groups_membership_accepted', $r['user_id'], $r['item_id'], true );
+                } else {
+                        /**
+                         * Fires after a user has accepted a group invite.
+                         *
+                         * @since 1.0.0
+                         * @since 2.8.0 The $inviter_id arg was added.
+                         *
+                         * @param int $user_id    ID of the user who accepted the group invite.
+                         * @param int $group_id   ID of the group being accepted to.
+                         * @param int $inviter_id ID of the user who invited this user to the group.
+                         */
+                        do_action( 'groups_accept_invite', $r['user_id'], $r['item_id'], $r['inviter_id'] );
+                }
+
                 // Modify group meta.
                 groups_update_groupmeta( $r['item_id'], 'last_activity', bp_core_current_time() );
 

tests/phpunit/testcases/groups/functions/bpGetUserGroups.php

@@ -26 +26 @@
                 ) );
                 self::$groups = $f->group->create_many( 4, array(
                         'creator_id' => self::$admin_user,
+                        'status'     => 'private'
                 ) );
 
                 $now = time();
@@ -516 +517 @@
                 $server_name = isset( $_SERVER['SERVER_NAME'] ) ? $_SERVER['SERVER_NAME'] : null;
                 $_SERVER['SERVER_NAME'] = '';
 
-                groups_send_membership_request( self::$user, self::$groups[2] );
+                groups_send_membership_request( array(
+                        'user_id' => self::$user,
+                        'group_id' => self::$groups[2]
+                ) );
 
                 // For `wp_mail()`.
                 if ( is_null( $server_name ) ) {

tests/phpunit/testcases/groups/notifications.php

@@ -16 +16 @@
                 $this->set_current_user( self::factory()->user->create() );
 
                 $this->requesting_user_id = self::factory()->user->create();
-                $this->group = self::factory()->group->create();
+                $this->group = self::factory()->group->create( array( 'status' =>  'private' ) );
                 $this->filter_fired = '';
         }
 
@@ -232 +232 @@
                         'is_admin' => 1,
                 ) );
 
-                groups_send_membership_request( $users[2], $this->group );
+                groups_send_membership_request( array(
+                        'user_id' => $users[2],
+                        'group_id' => $this->group
+                ) );
 
                 // Both admins should get a notification.
                 $get_args = array(
@@ -247 +250 @@
                 $this->assertNotEmpty( $u0_notifications );
                 $this->assertNotEmpty( $u1_notifications );
 
-                $this->assertTrue( groups_invite_user( array(
+                groups_accept_membership_request( false, $users[2], $this->group );
+
+                $u0_notifications = BP_Notifications_Notification::get( $get_args );
+                $u1_notifications = BP_Notifications_Notification::get( $get_args );
+                $this->assertEmpty( $u0_notifications );
+                $this->assertEmpty( $u1_notifications );
+        }
+
+        public function test_membership_request_notifications_should_be_cleared_when_request_is_accepted_via_invite() {
+                $users = self::factory()->user->create_many( 3 );
+
+                $this->add_user_to_group( $users[0], $this->group, array(
+                        'is_admin' => 1,
+                ) );
+                $this->add_user_to_group( $users[1], $this->group, array(
+                        'is_admin' => 1,
+                ) );
+
+                groups_send_membership_request( array(
+                        'user_id' => $users[2],
+                        'group_id' => $this->group
+                ) );
+
+                // Both admins should get a notification.
+                $get_args = array(
+                        'user_id' => $users[0],
+                        'item_id' => $this->group,
+                        'secondary_item_id' => $users[2],
+                        'component_action' => 'new_membership_request',
+                        'is_new' => true,
+                );
+                $u0_notifications = BP_Notifications_Notification::get( $get_args );
+                $u1_notifications = BP_Notifications_Notification::get( $get_args );
+                $this->assertNotEmpty( $u0_notifications );
+                $this->assertNotEmpty( $u1_notifications );
+
+                // 'Accept' the request by sending an invite.
+                groups_invite_user( array(
                         'user_id' => $users[2],
                         'group_id' => $this->group,
-                ) ) );
+                        'send_invite' => true
+                ) );
 
                 $u0_notifications = BP_Notifications_Notification::get( $get_args );
                 $u1_notifications = BP_Notifications_Notification::get( $get_args );